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 (t2); 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 && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
4102 && vector_types_convertible_p (TREE_TYPE (inside_init), type)
4103 && TREE_CONSTANT (inside_init))
4105 if (TREE_CODE (inside_init) == VECTOR_CST
4106 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4107 TYPE_MAIN_VARIANT (type),
4111 if (TREE_CODE (inside_init) == CONSTRUCTOR)
4115 /* Iterate through elements and check if all constructor
4116 elements are *_CSTs. */
4117 for (link = CONSTRUCTOR_ELTS (inside_init);
4119 link = TREE_CHAIN (link))
4120 if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (link))) != 'c')
4124 return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4128 /* Any type can be initialized
4129 from an expression of the same type, optionally with braces. */
4131 if (inside_init && TREE_TYPE (inside_init) != 0
4132 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4133 TYPE_MAIN_VARIANT (type), COMPARE_STRICT)
4134 || (code == ARRAY_TYPE
4135 && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
4136 || (code == VECTOR_TYPE
4137 && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
4138 || (code == POINTER_TYPE
4139 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4140 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4141 TREE_TYPE (type), COMPARE_STRICT))
4142 || (code == POINTER_TYPE
4143 && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
4144 && comptypes (TREE_TYPE (inside_init),
4145 TREE_TYPE (type), COMPARE_STRICT))))
4147 if (code == POINTER_TYPE)
4149 inside_init = default_function_array_conversion (inside_init);
4151 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4153 error_init ("invalid use of non-lvalue array");
4154 return error_mark_node;
4158 if (code == VECTOR_TYPE)
4159 /* Although the types are compatible, we may require a
4161 inside_init = convert (type, inside_init);
4163 if (require_constant && !flag_isoc99
4164 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4166 /* As an extension, allow initializing objects with static storage
4167 duration with compound literals (which are then treated just as
4168 the brace enclosed list they contain). */
4169 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4170 inside_init = DECL_INITIAL (decl);
4173 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4174 && TREE_CODE (inside_init) != CONSTRUCTOR)
4176 error_init ("array initialized from non-constant array expression");
4177 return error_mark_node;
4180 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4181 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4183 /* Compound expressions can only occur here if -pedantic or
4184 -pedantic-errors is specified. In the later case, we always want
4185 an error. In the former case, we simply want a warning. */
4186 if (require_constant && pedantic
4187 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4190 = valid_compound_expr_initializer (inside_init,
4191 TREE_TYPE (inside_init));
4192 if (inside_init == error_mark_node)
4193 error_init ("initializer element is not constant");
4195 pedwarn_init ("initializer element is not constant");
4196 if (flag_pedantic_errors)
4197 inside_init = error_mark_node;
4199 else if (require_constant
4200 && (!TREE_CONSTANT (inside_init)
4201 /* This test catches things like `7 / 0' which
4202 result in an expression for which TREE_CONSTANT
4203 is true, but which is not actually something
4204 that is a legal constant. We really should not
4205 be using this function, because it is a part of
4206 the back-end. Instead, the expression should
4207 already have been turned into ERROR_MARK_NODE. */
4208 || !initializer_constant_valid_p (inside_init,
4209 TREE_TYPE (inside_init))))
4211 error_init ("initializer element is not constant");
4212 inside_init = error_mark_node;
4218 /* Handle scalar types, including conversions. */
4220 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4221 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4223 /* Note that convert_for_assignment calls default_conversion
4224 for arrays and functions. We must not call it in the
4225 case where inside_init is a null pointer constant. */
4227 = convert_for_assignment (type, init, _("initialization"),
4228 NULL_TREE, NULL_TREE, 0);
4230 if (require_constant && ! TREE_CONSTANT (inside_init))
4232 error_init ("initializer element is not constant");
4233 inside_init = error_mark_node;
4235 else if (require_constant
4236 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4238 error_init ("initializer element is not computable at load time");
4239 inside_init = error_mark_node;
4245 /* Come here only for records and arrays. */
4247 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4249 error_init ("variable-sized object may not be initialized");
4250 return error_mark_node;
4253 error_init ("invalid initializer");
4254 return error_mark_node;
4257 /* Handle initializers that use braces. */
4259 /* Type of object we are accumulating a constructor for.
4260 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4261 static tree constructor_type;
4263 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4265 static tree constructor_fields;
4267 /* For an ARRAY_TYPE, this is the specified index
4268 at which to store the next element we get. */
4269 static tree constructor_index;
4271 /* For an ARRAY_TYPE, this is the maximum index. */
4272 static tree constructor_max_index;
4274 /* For a RECORD_TYPE, this is the first field not yet written out. */
4275 static tree constructor_unfilled_fields;
4277 /* For an ARRAY_TYPE, this is the index of the first element
4278 not yet written out. */
4279 static tree constructor_unfilled_index;
4281 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4282 This is so we can generate gaps between fields, when appropriate. */
4283 static tree constructor_bit_index;
4285 /* If we are saving up the elements rather than allocating them,
4286 this is the list of elements so far (in reverse order,
4287 most recent first). */
4288 static tree constructor_elements;
4290 /* 1 if constructor should be incrementally stored into a constructor chain,
4291 0 if all the elements should be kept in AVL tree. */
4292 static int constructor_incremental;
4294 /* 1 if so far this constructor's elements are all compile-time constants. */
4295 static int constructor_constant;
4297 /* 1 if so far this constructor's elements are all valid address constants. */
4298 static int constructor_simple;
4300 /* 1 if this constructor is erroneous so far. */
4301 static int constructor_erroneous;
4303 /* Structure for managing pending initializer elements, organized as an
4308 struct init_node *left, *right;
4309 struct init_node *parent;
4315 /* Tree of pending elements at this constructor level.
4316 These are elements encountered out of order
4317 which belong at places we haven't reached yet in actually
4319 Will never hold tree nodes across GC runs. */
4320 static struct init_node *constructor_pending_elts;
4322 /* The SPELLING_DEPTH of this constructor. */
4323 static int constructor_depth;
4325 /* 0 if implicitly pushing constructor levels is allowed. */
4326 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4328 /* DECL node for which an initializer is being read.
4329 0 means we are reading a constructor expression
4330 such as (struct foo) {...}. */
4331 static tree constructor_decl;
4333 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4334 static const char *constructor_asmspec;
4336 /* Nonzero if this is an initializer for a top-level decl. */
4337 static int constructor_top_level;
4339 /* Nonzero if there were any member designators in this initializer. */
4340 static int constructor_designated;
4342 /* Nesting depth of designator list. */
4343 static int designator_depth;
4345 /* Nonzero if there were diagnosed errors in this designator list. */
4346 static int designator_errorneous;
4349 /* This stack has a level for each implicit or explicit level of
4350 structuring in the initializer, including the outermost one. It
4351 saves the values of most of the variables above. */
4353 struct constructor_range_stack;
4355 struct constructor_stack
4357 struct constructor_stack *next;
4362 tree unfilled_index;
4363 tree unfilled_fields;
4366 struct init_node *pending_elts;
4369 /* If nonzero, this value should replace the entire
4370 constructor at this level. */
4371 tree replacement_value;
4372 struct constructor_range_stack *range_stack;
4382 struct constructor_stack *constructor_stack;
4384 /* This stack represents designators from some range designator up to
4385 the last designator in the list. */
4387 struct constructor_range_stack
4389 struct constructor_range_stack *next, *prev;
4390 struct constructor_stack *stack;
4397 struct constructor_range_stack *constructor_range_stack;
4399 /* This stack records separate initializers that are nested.
4400 Nested initializers can't happen in ANSI C, but GNU C allows them
4401 in cases like { ... (struct foo) { ... } ... }. */
4403 struct initializer_stack
4405 struct initializer_stack *next;
4407 const char *asmspec;
4408 struct constructor_stack *constructor_stack;
4409 struct constructor_range_stack *constructor_range_stack;
4411 struct spelling *spelling;
4412 struct spelling *spelling_base;
4415 char require_constant_value;
4416 char require_constant_elements;
4419 struct initializer_stack *initializer_stack;
4421 /* Prepare to parse and output the initializer for variable DECL. */
4424 start_init (tree decl, tree asmspec_tree, int top_level)
4427 struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4428 const char *asmspec = 0;
4431 asmspec = TREE_STRING_POINTER (asmspec_tree);
4433 p->decl = constructor_decl;
4434 p->asmspec = constructor_asmspec;
4435 p->require_constant_value = require_constant_value;
4436 p->require_constant_elements = require_constant_elements;
4437 p->constructor_stack = constructor_stack;
4438 p->constructor_range_stack = constructor_range_stack;
4439 p->elements = constructor_elements;
4440 p->spelling = spelling;
4441 p->spelling_base = spelling_base;
4442 p->spelling_size = spelling_size;
4443 p->top_level = constructor_top_level;
4444 p->next = initializer_stack;
4445 initializer_stack = p;
4447 constructor_decl = decl;
4448 constructor_asmspec = asmspec;
4449 constructor_designated = 0;
4450 constructor_top_level = top_level;
4454 require_constant_value = TREE_STATIC (decl);
4455 require_constant_elements
4456 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4457 /* For a scalar, you can always use any value to initialize,
4458 even within braces. */
4459 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4460 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4461 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4462 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4463 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4467 require_constant_value = 0;
4468 require_constant_elements = 0;
4469 locus = "(anonymous)";
4472 constructor_stack = 0;
4473 constructor_range_stack = 0;
4475 missing_braces_mentioned = 0;
4479 RESTORE_SPELLING_DEPTH (0);
4482 push_string (locus);
4488 struct initializer_stack *p = initializer_stack;
4490 /* Free the whole constructor stack of this initializer. */
4491 while (constructor_stack)
4493 struct constructor_stack *q = constructor_stack;
4494 constructor_stack = q->next;
4498 if (constructor_range_stack)
4501 /* Pop back to the data of the outer initializer (if any). */
4502 free (spelling_base);
4504 constructor_decl = p->decl;
4505 constructor_asmspec = p->asmspec;
4506 require_constant_value = p->require_constant_value;
4507 require_constant_elements = p->require_constant_elements;
4508 constructor_stack = p->constructor_stack;
4509 constructor_range_stack = p->constructor_range_stack;
4510 constructor_elements = p->elements;
4511 spelling = p->spelling;
4512 spelling_base = p->spelling_base;
4513 spelling_size = p->spelling_size;
4514 constructor_top_level = p->top_level;
4515 initializer_stack = p->next;
4519 /* Call here when we see the initializer is surrounded by braces.
4520 This is instead of a call to push_init_level;
4521 it is matched by a call to pop_init_level.
4523 TYPE is the type to initialize, for a constructor expression.
4524 For an initializer for a decl, TYPE is zero. */
4527 really_start_incremental_init (tree type)
4529 struct constructor_stack *p = xmalloc (sizeof (struct constructor_stack));
4532 type = TREE_TYPE (constructor_decl);
4534 if ((*targetm.vector_opaque_p) (type))
4535 error ("opaque vector types cannot be initialized");
4537 p->type = constructor_type;
4538 p->fields = constructor_fields;
4539 p->index = constructor_index;
4540 p->max_index = constructor_max_index;
4541 p->unfilled_index = constructor_unfilled_index;
4542 p->unfilled_fields = constructor_unfilled_fields;
4543 p->bit_index = constructor_bit_index;
4544 p->elements = constructor_elements;
4545 p->constant = constructor_constant;
4546 p->simple = constructor_simple;
4547 p->erroneous = constructor_erroneous;
4548 p->pending_elts = constructor_pending_elts;
4549 p->depth = constructor_depth;
4550 p->replacement_value = 0;
4554 p->incremental = constructor_incremental;
4555 p->designated = constructor_designated;
4557 constructor_stack = p;
4559 constructor_constant = 1;
4560 constructor_simple = 1;
4561 constructor_depth = SPELLING_DEPTH ();
4562 constructor_elements = 0;
4563 constructor_pending_elts = 0;
4564 constructor_type = type;
4565 constructor_incremental = 1;
4566 constructor_designated = 0;
4567 designator_depth = 0;
4568 designator_errorneous = 0;
4570 if (TREE_CODE (constructor_type) == RECORD_TYPE
4571 || TREE_CODE (constructor_type) == UNION_TYPE)
4573 constructor_fields = TYPE_FIELDS (constructor_type);
4574 /* Skip any nameless bit fields at the beginning. */
4575 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4576 && DECL_NAME (constructor_fields) == 0)
4577 constructor_fields = TREE_CHAIN (constructor_fields);
4579 constructor_unfilled_fields = constructor_fields;
4580 constructor_bit_index = bitsize_zero_node;
4582 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4584 if (TYPE_DOMAIN (constructor_type))
4586 constructor_max_index
4587 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4589 /* Detect non-empty initializations of zero-length arrays. */
4590 if (constructor_max_index == NULL_TREE
4591 && TYPE_SIZE (constructor_type))
4592 constructor_max_index = build_int_2 (-1, -1);
4594 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4595 to initialize VLAs will cause a proper error; avoid tree
4596 checking errors as well by setting a safe value. */
4597 if (constructor_max_index
4598 && TREE_CODE (constructor_max_index) != INTEGER_CST)
4599 constructor_max_index = build_int_2 (-1, -1);
4602 = convert (bitsizetype,
4603 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4606 constructor_index = bitsize_zero_node;
4608 constructor_unfilled_index = constructor_index;
4610 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4612 /* Vectors are like simple fixed-size arrays. */
4613 constructor_max_index =
4614 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4615 constructor_index = convert (bitsizetype, bitsize_zero_node);
4616 constructor_unfilled_index = constructor_index;
4620 /* Handle the case of int x = {5}; */
4621 constructor_fields = constructor_type;
4622 constructor_unfilled_fields = constructor_type;
4626 /* Push down into a subobject, for initialization.
4627 If this is for an explicit set of braces, IMPLICIT is 0.
4628 If it is because the next element belongs at a lower level,
4629 IMPLICIT is 1 (or 2 if the push is because of designator list). */
4632 push_init_level (int implicit)
4634 struct constructor_stack *p;
4635 tree value = NULL_TREE;
4637 /* If we've exhausted any levels that didn't have braces,
4638 pop them now. If implicit == 1, this will have been done in
4639 process_init_element; do not repeat it here because in the case
4640 of excess initializers for an empty aggregate this leads to an
4641 infinite cycle of popping a level and immediately recreating
4645 while (constructor_stack->implicit)
4647 if ((TREE_CODE (constructor_type) == RECORD_TYPE
4648 || TREE_CODE (constructor_type) == UNION_TYPE)
4649 && constructor_fields == 0)
4650 process_init_element (pop_init_level (1));
4651 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4652 && constructor_max_index
4653 && tree_int_cst_lt (constructor_max_index,
4655 process_init_element (pop_init_level (1));
4661 /* Unless this is an explicit brace, we need to preserve previous
4665 if ((TREE_CODE (constructor_type) == RECORD_TYPE
4666 || TREE_CODE (constructor_type) == UNION_TYPE)
4667 && constructor_fields)
4668 value = find_init_member (constructor_fields);
4669 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4670 value = find_init_member (constructor_index);
4673 p = xmalloc (sizeof (struct constructor_stack));
4674 p->type = constructor_type;
4675 p->fields = constructor_fields;
4676 p->index = constructor_index;
4677 p->max_index = constructor_max_index;
4678 p->unfilled_index = constructor_unfilled_index;
4679 p->unfilled_fields = constructor_unfilled_fields;
4680 p->bit_index = constructor_bit_index;
4681 p->elements = constructor_elements;
4682 p->constant = constructor_constant;
4683 p->simple = constructor_simple;
4684 p->erroneous = constructor_erroneous;
4685 p->pending_elts = constructor_pending_elts;
4686 p->depth = constructor_depth;
4687 p->replacement_value = 0;
4688 p->implicit = implicit;
4690 p->incremental = constructor_incremental;
4691 p->designated = constructor_designated;
4692 p->next = constructor_stack;
4694 constructor_stack = p;
4696 constructor_constant = 1;
4697 constructor_simple = 1;
4698 constructor_depth = SPELLING_DEPTH ();
4699 constructor_elements = 0;
4700 constructor_incremental = 1;
4701 constructor_designated = 0;
4702 constructor_pending_elts = 0;
4705 p->range_stack = constructor_range_stack;
4706 constructor_range_stack = 0;
4707 designator_depth = 0;
4708 designator_errorneous = 0;
4711 /* Don't die if an entire brace-pair level is superfluous
4712 in the containing level. */
4713 if (constructor_type == 0)
4715 else if (TREE_CODE (constructor_type) == RECORD_TYPE
4716 || TREE_CODE (constructor_type) == UNION_TYPE)
4718 /* Don't die if there are extra init elts at the end. */
4719 if (constructor_fields == 0)
4720 constructor_type = 0;
4723 constructor_type = TREE_TYPE (constructor_fields);
4724 push_member_name (constructor_fields);
4725 constructor_depth++;
4728 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4730 constructor_type = TREE_TYPE (constructor_type);
4731 push_array_bounds (tree_low_cst (constructor_index, 0));
4732 constructor_depth++;
4735 if (constructor_type == 0)
4737 error_init ("extra brace group at end of initializer");
4738 constructor_fields = 0;
4739 constructor_unfilled_fields = 0;
4743 if (value && TREE_CODE (value) == CONSTRUCTOR)
4745 constructor_constant = TREE_CONSTANT (value);
4746 constructor_simple = TREE_STATIC (value);
4747 constructor_elements = CONSTRUCTOR_ELTS (value);
4748 if (constructor_elements
4749 && (TREE_CODE (constructor_type) == RECORD_TYPE
4750 || TREE_CODE (constructor_type) == ARRAY_TYPE))
4751 set_nonincremental_init ();
4754 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4756 missing_braces_mentioned = 1;
4757 warning_init ("missing braces around initializer");
4760 if (TREE_CODE (constructor_type) == RECORD_TYPE
4761 || TREE_CODE (constructor_type) == UNION_TYPE)
4763 constructor_fields = TYPE_FIELDS (constructor_type);
4764 /* Skip any nameless bit fields at the beginning. */
4765 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4766 && DECL_NAME (constructor_fields) == 0)
4767 constructor_fields = TREE_CHAIN (constructor_fields);
4769 constructor_unfilled_fields = constructor_fields;
4770 constructor_bit_index = bitsize_zero_node;
4772 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4774 /* Vectors are like simple fixed-size arrays. */
4775 constructor_max_index =
4776 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4777 constructor_index = convert (bitsizetype, integer_zero_node);
4778 constructor_unfilled_index = constructor_index;
4780 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4782 if (TYPE_DOMAIN (constructor_type))
4784 constructor_max_index
4785 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4787 /* Detect non-empty initializations of zero-length arrays. */
4788 if (constructor_max_index == NULL_TREE
4789 && TYPE_SIZE (constructor_type))
4790 constructor_max_index = build_int_2 (-1, -1);
4792 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4793 to initialize VLAs will cause a proper error; avoid tree
4794 checking errors as well by setting a safe value. */
4795 if (constructor_max_index
4796 && TREE_CODE (constructor_max_index) != INTEGER_CST)
4797 constructor_max_index = build_int_2 (-1, -1);
4800 = convert (bitsizetype,
4801 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4804 constructor_index = bitsize_zero_node;
4806 constructor_unfilled_index = constructor_index;
4807 if (value && TREE_CODE (value) == STRING_CST)
4809 /* We need to split the char/wchar array into individual
4810 characters, so that we don't have to special case it
4812 set_nonincremental_init_from_string (value);
4817 warning_init ("braces around scalar initializer");
4818 constructor_fields = constructor_type;
4819 constructor_unfilled_fields = constructor_type;
4823 /* At the end of an implicit or explicit brace level,
4824 finish up that level of constructor.
4825 If we were outputting the elements as they are read, return 0
4826 from inner levels (process_init_element ignores that),
4827 but return error_mark_node from the outermost level
4828 (that's what we want to put in DECL_INITIAL).
4829 Otherwise, return a CONSTRUCTOR expression. */
4832 pop_init_level (int implicit)
4834 struct constructor_stack *p;
4835 tree constructor = 0;
4839 /* When we come to an explicit close brace,
4840 pop any inner levels that didn't have explicit braces. */
4841 while (constructor_stack->implicit)
4842 process_init_element (pop_init_level (1));
4844 if (constructor_range_stack)
4848 /* Now output all pending elements. */
4849 constructor_incremental = 1;
4850 output_pending_init_elements (1);
4852 p = constructor_stack;
4854 /* Error for initializing a flexible array member, or a zero-length
4855 array member in an inappropriate context. */
4856 if (constructor_type && constructor_fields
4857 && TREE_CODE (constructor_type) == ARRAY_TYPE
4858 && TYPE_DOMAIN (constructor_type)
4859 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4861 /* Silently discard empty initializations. The parser will
4862 already have pedwarned for empty brackets. */
4863 if (integer_zerop (constructor_unfilled_index))
4864 constructor_type = NULL_TREE;
4865 else if (! TYPE_SIZE (constructor_type))
4867 if (constructor_depth > 2)
4868 error_init ("initialization of flexible array member in a nested context");
4870 pedwarn_init ("initialization of a flexible array member");
4872 /* We have already issued an error message for the existence
4873 of a flexible array member not at the end of the structure.
4874 Discard the initializer so that we do not abort later. */
4875 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4876 constructor_type = NULL_TREE;
4879 /* Zero-length arrays are no longer special, so we should no longer
4884 /* Warn when some struct elements are implicitly initialized to zero. */
4887 && TREE_CODE (constructor_type) == RECORD_TYPE
4888 && constructor_unfilled_fields)
4890 /* Do not warn for flexible array members or zero-length arrays. */
4891 while (constructor_unfilled_fields
4892 && (! DECL_SIZE (constructor_unfilled_fields)
4893 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4894 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4896 /* Do not warn if this level of the initializer uses member
4897 designators; it is likely to be deliberate. */
4898 if (constructor_unfilled_fields && !constructor_designated)
4900 push_member_name (constructor_unfilled_fields);
4901 warning_init ("missing initializer");
4902 RESTORE_SPELLING_DEPTH (constructor_depth);
4906 /* Pad out the end of the structure. */
4907 if (p->replacement_value)
4908 /* If this closes a superfluous brace pair,
4909 just pass out the element between them. */
4910 constructor = p->replacement_value;
4911 else if (constructor_type == 0)
4913 else if (TREE_CODE (constructor_type) != RECORD_TYPE
4914 && TREE_CODE (constructor_type) != UNION_TYPE
4915 && TREE_CODE (constructor_type) != ARRAY_TYPE
4916 && TREE_CODE (constructor_type) != VECTOR_TYPE)
4918 /* A nonincremental scalar initializer--just return
4919 the element, after verifying there is just one. */
4920 if (constructor_elements == 0)
4922 if (!constructor_erroneous)
4923 error_init ("empty scalar initializer");
4924 constructor = error_mark_node;
4926 else if (TREE_CHAIN (constructor_elements) != 0)
4928 error_init ("extra elements in scalar initializer");
4929 constructor = TREE_VALUE (constructor_elements);
4932 constructor = TREE_VALUE (constructor_elements);
4936 if (constructor_erroneous)
4937 constructor = error_mark_node;
4940 constructor = build_constructor (constructor_type,
4941 nreverse (constructor_elements));
4942 if (constructor_constant)
4943 TREE_CONSTANT (constructor) = 1;
4944 if (constructor_constant && constructor_simple)
4945 TREE_STATIC (constructor) = 1;
4949 constructor_type = p->type;
4950 constructor_fields = p->fields;
4951 constructor_index = p->index;
4952 constructor_max_index = p->max_index;
4953 constructor_unfilled_index = p->unfilled_index;
4954 constructor_unfilled_fields = p->unfilled_fields;
4955 constructor_bit_index = p->bit_index;
4956 constructor_elements = p->elements;
4957 constructor_constant = p->constant;
4958 constructor_simple = p->simple;
4959 constructor_erroneous = p->erroneous;
4960 constructor_incremental = p->incremental;
4961 constructor_designated = p->designated;
4962 constructor_pending_elts = p->pending_elts;
4963 constructor_depth = p->depth;
4965 constructor_range_stack = p->range_stack;
4966 RESTORE_SPELLING_DEPTH (constructor_depth);
4968 constructor_stack = p->next;
4971 if (constructor == 0)
4973 if (constructor_stack == 0)
4974 return error_mark_node;
4980 /* Common handling for both array range and field name designators.
4981 ARRAY argument is nonzero for array ranges. Returns zero for success. */
4984 set_designator (int array)
4987 enum tree_code subcode;
4989 /* Don't die if an entire brace-pair level is superfluous
4990 in the containing level. */
4991 if (constructor_type == 0)
4994 /* If there were errors in this designator list already, bail out silently. */
4995 if (designator_errorneous)
4998 if (!designator_depth)
5000 if (constructor_range_stack)
5003 /* Designator list starts at the level of closest explicit
5005 while (constructor_stack->implicit)
5006 process_init_element (pop_init_level (1));
5007 constructor_designated = 1;
5011 if (constructor_no_implicit)
5013 error_init ("initialization designators may not nest");
5017 if (TREE_CODE (constructor_type) == RECORD_TYPE
5018 || TREE_CODE (constructor_type) == UNION_TYPE)
5020 subtype = TREE_TYPE (constructor_fields);
5021 if (subtype != error_mark_node)
5022 subtype = TYPE_MAIN_VARIANT (subtype);
5024 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5026 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5031 subcode = TREE_CODE (subtype);
5032 if (array && subcode != ARRAY_TYPE)
5034 error_init ("array index in non-array initializer");
5037 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5039 error_init ("field name not in record or union initializer");
5043 constructor_designated = 1;
5044 push_init_level (2);
5048 /* If there are range designators in designator list, push a new designator
5049 to constructor_range_stack. RANGE_END is end of such stack range or
5050 NULL_TREE if there is no range designator at this level. */
5053 push_range_stack (tree range_end)
5055 struct constructor_range_stack *p;
5057 p = ggc_alloc (sizeof (struct constructor_range_stack));
5058 p->prev = constructor_range_stack;
5060 p->fields = constructor_fields;
5061 p->range_start = constructor_index;
5062 p->index = constructor_index;
5063 p->stack = constructor_stack;
5064 p->range_end = range_end;
5065 if (constructor_range_stack)
5066 constructor_range_stack->next = p;
5067 constructor_range_stack = p;
5070 /* Within an array initializer, specify the next index to be initialized.
5071 FIRST is that index. If LAST is nonzero, then initialize a range
5072 of indices, running from FIRST through LAST. */
5075 set_init_index (tree first, tree last)
5077 if (set_designator (1))
5080 designator_errorneous = 1;
5082 while ((TREE_CODE (first) == NOP_EXPR
5083 || TREE_CODE (first) == CONVERT_EXPR
5084 || TREE_CODE (first) == NON_LVALUE_EXPR)
5085 && (TYPE_MODE (TREE_TYPE (first))
5086 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5087 first = TREE_OPERAND (first, 0);
5090 while ((TREE_CODE (last) == NOP_EXPR
5091 || TREE_CODE (last) == CONVERT_EXPR
5092 || TREE_CODE (last) == NON_LVALUE_EXPR)
5093 && (TYPE_MODE (TREE_TYPE (last))
5094 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5095 last = TREE_OPERAND (last, 0);
5097 if (TREE_CODE (first) != INTEGER_CST)
5098 error_init ("nonconstant array index in initializer");
5099 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5100 error_init ("nonconstant array index in initializer");
5101 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5102 error_init ("array index in non-array initializer");
5103 else if (tree_int_cst_sgn (first) == -1)
5104 error_init ("array index in initializer exceeds array bounds");
5105 else if (constructor_max_index
5106 && tree_int_cst_lt (constructor_max_index, first))
5107 error_init ("array index in initializer exceeds array bounds");
5110 constructor_index = convert (bitsizetype, first);
5114 if (tree_int_cst_equal (first, last))
5116 else if (tree_int_cst_lt (last, first))
5118 error_init ("empty index range in initializer");
5123 last = convert (bitsizetype, last);
5124 if (constructor_max_index != 0
5125 && tree_int_cst_lt (constructor_max_index, last))
5127 error_init ("array index range in initializer exceeds array bounds");
5134 designator_errorneous = 0;
5135 if (constructor_range_stack || last)
5136 push_range_stack (last);
5140 /* Within a struct initializer, specify the next field to be initialized. */
5143 set_init_label (tree fieldname)
5147 if (set_designator (0))
5150 designator_errorneous = 1;
5152 if (TREE_CODE (constructor_type) != RECORD_TYPE
5153 && TREE_CODE (constructor_type) != UNION_TYPE)
5155 error_init ("field name not in record or union initializer");
5159 for (tail = TYPE_FIELDS (constructor_type); tail;
5160 tail = TREE_CHAIN (tail))
5162 if (DECL_NAME (tail) == fieldname)
5167 error ("unknown field `%s' specified in initializer",
5168 IDENTIFIER_POINTER (fieldname));
5171 constructor_fields = tail;
5173 designator_errorneous = 0;
5174 if (constructor_range_stack)
5175 push_range_stack (NULL_TREE);
5179 /* Add a new initializer to the tree of pending initializers. PURPOSE
5180 identifies the initializer, either array index or field in a structure.
5181 VALUE is the value of that index or field. */
5184 add_pending_init (tree purpose, tree value)
5186 struct init_node *p, **q, *r;
5188 q = &constructor_pending_elts;
5191 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5196 if (tree_int_cst_lt (purpose, p->purpose))
5198 else if (tree_int_cst_lt (p->purpose, purpose))
5202 if (TREE_SIDE_EFFECTS (p->value))
5203 warning_init ("initialized field with side-effects overwritten");
5213 bitpos = bit_position (purpose);
5217 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5219 else if (p->purpose != purpose)
5223 if (TREE_SIDE_EFFECTS (p->value))
5224 warning_init ("initialized field with side-effects overwritten");
5231 r = ggc_alloc (sizeof (struct init_node));
5232 r->purpose = purpose;
5243 struct init_node *s;
5247 if (p->balance == 0)
5249 else if (p->balance < 0)
5256 p->left->parent = p;
5273 constructor_pending_elts = r;
5278 struct init_node *t = r->right;
5282 r->right->parent = r;
5287 p->left->parent = p;
5290 p->balance = t->balance < 0;
5291 r->balance = -(t->balance > 0);
5306 constructor_pending_elts = t;
5312 /* p->balance == +1; growth of left side balances the node. */
5317 else /* r == p->right */
5319 if (p->balance == 0)
5320 /* Growth propagation from right side. */
5322 else if (p->balance > 0)
5329 p->right->parent = p;
5346 constructor_pending_elts = r;
5348 else /* r->balance == -1 */
5351 struct init_node *t = r->left;
5355 r->left->parent = r;
5360 p->right->parent = p;
5363 r->balance = (t->balance < 0);
5364 p->balance = -(t->balance > 0);
5379 constructor_pending_elts = t;
5385 /* p->balance == -1; growth of right side balances the node. */
5396 /* Build AVL tree from a sorted chain. */
5399 set_nonincremental_init (void)
5403 if (TREE_CODE (constructor_type) != RECORD_TYPE
5404 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5407 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5408 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5409 constructor_elements = 0;
5410 if (TREE_CODE (constructor_type) == RECORD_TYPE)
5412 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5413 /* Skip any nameless bit fields at the beginning. */
5414 while (constructor_unfilled_fields != 0
5415 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5416 && DECL_NAME (constructor_unfilled_fields) == 0)
5417 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5420 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5422 if (TYPE_DOMAIN (constructor_type))
5423 constructor_unfilled_index
5424 = convert (bitsizetype,
5425 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5427 constructor_unfilled_index = bitsize_zero_node;
5429 constructor_incremental = 0;
5432 /* Build AVL tree from a string constant. */
5435 set_nonincremental_init_from_string (tree str)
5437 tree value, purpose, type;
5438 HOST_WIDE_INT val[2];
5439 const char *p, *end;
5440 int byte, wchar_bytes, charwidth, bitpos;
5442 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5445 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5446 == TYPE_PRECISION (char_type_node))
5448 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5449 == TYPE_PRECISION (wchar_type_node))
5450 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5454 charwidth = TYPE_PRECISION (char_type_node);
5455 type = TREE_TYPE (constructor_type);
5456 p = TREE_STRING_POINTER (str);
5457 end = p + TREE_STRING_LENGTH (str);
5459 for (purpose = bitsize_zero_node;
5460 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5461 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5463 if (wchar_bytes == 1)
5465 val[1] = (unsigned char) *p++;
5472 for (byte = 0; byte < wchar_bytes; byte++)
5474 if (BYTES_BIG_ENDIAN)
5475 bitpos = (wchar_bytes - byte - 1) * charwidth;
5477 bitpos = byte * charwidth;
5478 val[bitpos < HOST_BITS_PER_WIDE_INT]
5479 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5480 << (bitpos % HOST_BITS_PER_WIDE_INT);
5484 if (!TREE_UNSIGNED (type))
5486 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5487 if (bitpos < HOST_BITS_PER_WIDE_INT)
5489 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5491 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5495 else if (bitpos == HOST_BITS_PER_WIDE_INT)
5500 else if (val[0] & (((HOST_WIDE_INT) 1)
5501 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5502 val[0] |= ((HOST_WIDE_INT) -1)
5503 << (bitpos - HOST_BITS_PER_WIDE_INT);
5506 value = build_int_2 (val[1], val[0]);
5507 TREE_TYPE (value) = type;
5508 add_pending_init (purpose, value);
5511 constructor_incremental = 0;
5514 /* Return value of FIELD in pending initializer or zero if the field was
5515 not initialized yet. */
5518 find_init_member (tree field)
5520 struct init_node *p;
5522 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5524 if (constructor_incremental
5525 && tree_int_cst_lt (field, constructor_unfilled_index))
5526 set_nonincremental_init ();
5528 p = constructor_pending_elts;
5531 if (tree_int_cst_lt (field, p->purpose))
5533 else if (tree_int_cst_lt (p->purpose, field))
5539 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5541 tree bitpos = bit_position (field);
5543 if (constructor_incremental
5544 && (!constructor_unfilled_fields
5545 || tree_int_cst_lt (bitpos,
5546 bit_position (constructor_unfilled_fields))))
5547 set_nonincremental_init ();
5549 p = constructor_pending_elts;
5552 if (field == p->purpose)
5554 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5560 else if (TREE_CODE (constructor_type) == UNION_TYPE)
5562 if (constructor_elements
5563 && TREE_PURPOSE (constructor_elements) == field)
5564 return TREE_VALUE (constructor_elements);
5569 /* "Output" the next constructor element.
5570 At top level, really output it to assembler code now.
5571 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5572 TYPE is the data type that the containing data type wants here.
5573 FIELD is the field (a FIELD_DECL) or the index that this element fills.
5575 PENDING if non-nil means output pending elements that belong
5576 right after this element. (PENDING is normally 1;
5577 it is 0 while outputting pending elements, to avoid recursion.) */
5580 output_init_element (tree value, tree type, tree field, int pending)
5582 if (type == error_mark_node)
5584 constructor_erroneous = 1;
5587 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5588 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5589 && !(TREE_CODE (value) == STRING_CST
5590 && TREE_CODE (type) == ARRAY_TYPE
5591 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5592 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5593 TYPE_MAIN_VARIANT (type), COMPARE_STRICT)))
5594 value = default_conversion (value);
5596 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5597 && require_constant_value && !flag_isoc99 && pending)
5599 /* As an extension, allow initializing objects with static storage
5600 duration with compound literals (which are then treated just as
5601 the brace enclosed list they contain). */
5602 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5603 value = DECL_INITIAL (decl);
5606 if (value == error_mark_node)
5607 constructor_erroneous = 1;
5608 else if (!TREE_CONSTANT (value))
5609 constructor_constant = 0;
5610 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5611 || ((TREE_CODE (constructor_type) == RECORD_TYPE
5612 || TREE_CODE (constructor_type) == UNION_TYPE)
5613 && DECL_C_BIT_FIELD (field)
5614 && TREE_CODE (value) != INTEGER_CST))
5615 constructor_simple = 0;
5617 if (require_constant_value && ! TREE_CONSTANT (value))
5619 error_init ("initializer element is not constant");
5620 value = error_mark_node;
5622 else if (require_constant_elements
5623 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5624 pedwarn ("initializer element is not computable at load time");
5626 /* If this field is empty (and not at the end of structure),
5627 don't do anything other than checking the initializer. */
5629 && (TREE_TYPE (field) == error_mark_node
5630 || (COMPLETE_TYPE_P (TREE_TYPE (field))
5631 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5632 && (TREE_CODE (constructor_type) == ARRAY_TYPE
5633 || TREE_CHAIN (field)))))
5636 value = digest_init (type, value, require_constant_value);
5637 if (value == error_mark_node)
5639 constructor_erroneous = 1;
5643 /* If this element doesn't come next in sequence,
5644 put it on constructor_pending_elts. */
5645 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5646 && (!constructor_incremental
5647 || !tree_int_cst_equal (field, constructor_unfilled_index)))
5649 if (constructor_incremental
5650 && tree_int_cst_lt (field, constructor_unfilled_index))
5651 set_nonincremental_init ();
5653 add_pending_init (field, value);
5656 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5657 && (!constructor_incremental
5658 || field != constructor_unfilled_fields))
5660 /* We do this for records but not for unions. In a union,
5661 no matter which field is specified, it can be initialized
5662 right away since it starts at the beginning of the union. */
5663 if (constructor_incremental)
5665 if (!constructor_unfilled_fields)
5666 set_nonincremental_init ();
5669 tree bitpos, unfillpos;
5671 bitpos = bit_position (field);
5672 unfillpos = bit_position (constructor_unfilled_fields);
5674 if (tree_int_cst_lt (bitpos, unfillpos))
5675 set_nonincremental_init ();
5679 add_pending_init (field, value);
5682 else if (TREE_CODE (constructor_type) == UNION_TYPE
5683 && constructor_elements)
5685 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5686 warning_init ("initialized field with side-effects overwritten");
5688 /* We can have just one union field set. */
5689 constructor_elements = 0;
5692 /* Otherwise, output this element either to
5693 constructor_elements or to the assembler file. */
5695 if (field && TREE_CODE (field) == INTEGER_CST)
5696 field = copy_node (field);
5697 constructor_elements
5698 = tree_cons (field, value, constructor_elements);
5700 /* Advance the variable that indicates sequential elements output. */
5701 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5702 constructor_unfilled_index
5703 = size_binop (PLUS_EXPR, constructor_unfilled_index,
5705 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5707 constructor_unfilled_fields
5708 = TREE_CHAIN (constructor_unfilled_fields);
5710 /* Skip any nameless bit fields. */
5711 while (constructor_unfilled_fields != 0
5712 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5713 && DECL_NAME (constructor_unfilled_fields) == 0)
5714 constructor_unfilled_fields =
5715 TREE_CHAIN (constructor_unfilled_fields);
5717 else if (TREE_CODE (constructor_type) == UNION_TYPE)
5718 constructor_unfilled_fields = 0;
5720 /* Now output any pending elements which have become next. */
5722 output_pending_init_elements (0);
5725 /* Output any pending elements which have become next.
5726 As we output elements, constructor_unfilled_{fields,index}
5727 advances, which may cause other elements to become next;
5728 if so, they too are output.
5730 If ALL is 0, we return when there are
5731 no more pending elements to output now.
5733 If ALL is 1, we output space as necessary so that
5734 we can output all the pending elements. */
5737 output_pending_init_elements (int all)
5739 struct init_node *elt = constructor_pending_elts;
5744 /* Look through the whole pending tree.
5745 If we find an element that should be output now,
5746 output it. Otherwise, set NEXT to the element
5747 that comes first among those still pending. */
5752 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5754 if (tree_int_cst_equal (elt->purpose,
5755 constructor_unfilled_index))
5756 output_init_element (elt->value,
5757 TREE_TYPE (constructor_type),
5758 constructor_unfilled_index, 0);
5759 else if (tree_int_cst_lt (constructor_unfilled_index,
5762 /* Advance to the next smaller node. */
5767 /* We have reached the smallest node bigger than the
5768 current unfilled index. Fill the space first. */
5769 next = elt->purpose;
5775 /* Advance to the next bigger node. */
5780 /* We have reached the biggest node in a subtree. Find
5781 the parent of it, which is the next bigger node. */
5782 while (elt->parent && elt->parent->right == elt)
5785 if (elt && tree_int_cst_lt (constructor_unfilled_index,
5788 next = elt->purpose;
5794 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5795 || TREE_CODE (constructor_type) == UNION_TYPE)
5797 tree ctor_unfilled_bitpos, elt_bitpos;
5799 /* If the current record is complete we are done. */
5800 if (constructor_unfilled_fields == 0)
5803 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5804 elt_bitpos = bit_position (elt->purpose);
5805 /* We can't compare fields here because there might be empty
5806 fields in between. */
5807 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5809 constructor_unfilled_fields = elt->purpose;
5810 output_init_element (elt->value, TREE_TYPE (elt->purpose),
5813 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5815 /* Advance to the next smaller node. */
5820 /* We have reached the smallest node bigger than the
5821 current unfilled field. Fill the space first. */
5822 next = elt->purpose;
5828 /* Advance to the next bigger node. */
5833 /* We have reached the biggest node in a subtree. Find
5834 the parent of it, which is the next bigger node. */
5835 while (elt->parent && elt->parent->right == elt)
5839 && (tree_int_cst_lt (ctor_unfilled_bitpos,
5840 bit_position (elt->purpose))))
5842 next = elt->purpose;
5850 /* Ordinarily return, but not if we want to output all
5851 and there are elements left. */
5852 if (! (all && next != 0))
5855 /* If it's not incremental, just skip over the gap, so that after
5856 jumping to retry we will output the next successive element. */
5857 if (TREE_CODE (constructor_type) == RECORD_TYPE
5858 || TREE_CODE (constructor_type) == UNION_TYPE)
5859 constructor_unfilled_fields = next;
5860 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5861 constructor_unfilled_index = next;
5863 /* ELT now points to the node in the pending tree with the next
5864 initializer to output. */
5868 /* Add one non-braced element to the current constructor level.
5869 This adjusts the current position within the constructor's type.
5870 This may also start or terminate implicit levels
5871 to handle a partly-braced initializer.
5873 Once this has found the correct level for the new element,
5874 it calls output_init_element. */
5877 process_init_element (tree value)
5879 tree orig_value = value;
5880 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
5882 designator_depth = 0;
5883 designator_errorneous = 0;
5885 /* Handle superfluous braces around string cst as in
5886 char x[] = {"foo"}; */
5889 && TREE_CODE (constructor_type) == ARRAY_TYPE
5890 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
5891 && integer_zerop (constructor_unfilled_index))
5893 if (constructor_stack->replacement_value)
5894 error_init ("excess elements in char array initializer");
5895 constructor_stack->replacement_value = value;
5899 if (constructor_stack->replacement_value != 0)
5901 error_init ("excess elements in struct initializer");
5905 /* Ignore elements of a brace group if it is entirely superfluous
5906 and has already been diagnosed. */
5907 if (constructor_type == 0)
5910 /* If we've exhausted any levels that didn't have braces,
5912 while (constructor_stack->implicit)
5914 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5915 || TREE_CODE (constructor_type) == UNION_TYPE)
5916 && constructor_fields == 0)
5917 process_init_element (pop_init_level (1));
5918 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5919 && (constructor_max_index == 0
5920 || tree_int_cst_lt (constructor_max_index,
5921 constructor_index)))
5922 process_init_element (pop_init_level (1));
5927 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
5928 if (constructor_range_stack)
5930 /* If value is a compound literal and we'll be just using its
5931 content, don't put it into a SAVE_EXPR. */
5932 if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
5933 || !require_constant_value
5935 value = save_expr (value);
5940 if (TREE_CODE (constructor_type) == RECORD_TYPE)
5943 enum tree_code fieldcode;
5945 if (constructor_fields == 0)
5947 pedwarn_init ("excess elements in struct initializer");
5951 fieldtype = TREE_TYPE (constructor_fields);
5952 if (fieldtype != error_mark_node)
5953 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5954 fieldcode = TREE_CODE (fieldtype);
5956 /* Error for non-static initialization of a flexible array member. */
5957 if (fieldcode == ARRAY_TYPE
5958 && !require_constant_value
5959 && TYPE_SIZE (fieldtype) == NULL_TREE
5960 && TREE_CHAIN (constructor_fields) == NULL_TREE)
5962 error_init ("non-static initialization of a flexible array member");
5966 /* Accept a string constant to initialize a subarray. */
5968 && fieldcode == ARRAY_TYPE
5969 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5972 /* Otherwise, if we have come to a subaggregate,
5973 and we don't have an element of its type, push into it. */
5974 else if (value != 0 && !constructor_no_implicit
5975 && value != error_mark_node
5976 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5977 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5978 || fieldcode == UNION_TYPE))
5980 push_init_level (1);
5986 push_member_name (constructor_fields);
5987 output_init_element (value, fieldtype, constructor_fields, 1);
5988 RESTORE_SPELLING_DEPTH (constructor_depth);
5991 /* Do the bookkeeping for an element that was
5992 directly output as a constructor. */
5994 /* For a record, keep track of end position of last field. */
5995 if (DECL_SIZE (constructor_fields))
5996 constructor_bit_index
5997 = size_binop (PLUS_EXPR,
5998 bit_position (constructor_fields),
5999 DECL_SIZE (constructor_fields));
6001 /* If the current field was the first one not yet written out,
6002 it isn't now, so update. */
6003 if (constructor_unfilled_fields == constructor_fields)
6005 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6006 /* Skip any nameless bit fields. */
6007 while (constructor_unfilled_fields != 0
6008 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6009 && DECL_NAME (constructor_unfilled_fields) == 0)
6010 constructor_unfilled_fields =
6011 TREE_CHAIN (constructor_unfilled_fields);
6015 constructor_fields = TREE_CHAIN (constructor_fields);
6016 /* Skip any nameless bit fields at the beginning. */
6017 while (constructor_fields != 0
6018 && DECL_C_BIT_FIELD (constructor_fields)
6019 && DECL_NAME (constructor_fields) == 0)
6020 constructor_fields = TREE_CHAIN (constructor_fields);
6022 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6025 enum tree_code fieldcode;
6027 if (constructor_fields == 0)
6029 pedwarn_init ("excess elements in union initializer");
6033 fieldtype = TREE_TYPE (constructor_fields);
6034 if (fieldtype != error_mark_node)
6035 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6036 fieldcode = TREE_CODE (fieldtype);
6038 /* Warn that traditional C rejects initialization of unions.
6039 We skip the warning if the value is zero. This is done
6040 under the assumption that the zero initializer in user
6041 code appears conditioned on e.g. __STDC__ to avoid
6042 "missing initializer" warnings and relies on default
6043 initialization to zero in the traditional C case.
6044 We also skip the warning if the initializer is designated,
6045 again on the assumption that this must be conditional on
6046 __STDC__ anyway (and we've already complained about the
6047 member-designator already). */
6048 if (warn_traditional && !in_system_header && !constructor_designated
6049 && !(value && (integer_zerop (value) || real_zerop (value))))
6050 warning ("traditional C rejects initialization of unions");
6052 /* Accept a string constant to initialize a subarray. */
6054 && fieldcode == ARRAY_TYPE
6055 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6058 /* Otherwise, if we have come to a subaggregate,
6059 and we don't have an element of its type, push into it. */
6060 else if (value != 0 && !constructor_no_implicit
6061 && value != error_mark_node
6062 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6063 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6064 || fieldcode == UNION_TYPE))
6066 push_init_level (1);
6072 push_member_name (constructor_fields);
6073 output_init_element (value, fieldtype, constructor_fields, 1);
6074 RESTORE_SPELLING_DEPTH (constructor_depth);
6077 /* Do the bookkeeping for an element that was
6078 directly output as a constructor. */
6080 constructor_bit_index = DECL_SIZE (constructor_fields);
6081 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6084 constructor_fields = 0;
6086 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6088 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6089 enum tree_code eltcode = TREE_CODE (elttype);
6091 /* Accept a string constant to initialize a subarray. */
6093 && eltcode == ARRAY_TYPE
6094 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6097 /* Otherwise, if we have come to a subaggregate,
6098 and we don't have an element of its type, push into it. */
6099 else if (value != 0 && !constructor_no_implicit
6100 && value != error_mark_node
6101 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6102 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6103 || eltcode == UNION_TYPE))
6105 push_init_level (1);
6109 if (constructor_max_index != 0
6110 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6111 || integer_all_onesp (constructor_max_index)))
6113 pedwarn_init ("excess elements in array initializer");
6117 /* Now output the actual element. */
6120 push_array_bounds (tree_low_cst (constructor_index, 0));
6121 output_init_element (value, elttype, constructor_index, 1);
6122 RESTORE_SPELLING_DEPTH (constructor_depth);
6126 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6129 /* If we are doing the bookkeeping for an element that was
6130 directly output as a constructor, we must update
6131 constructor_unfilled_index. */
6132 constructor_unfilled_index = constructor_index;
6134 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6136 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6138 /* Do a basic check of initializer size. Note that vectors
6139 always have a fixed size derived from their type. */
6140 if (tree_int_cst_lt (constructor_max_index, constructor_index))
6142 pedwarn_init ("excess elements in vector initializer");
6146 /* Now output the actual element. */
6148 output_init_element (value, elttype, constructor_index, 1);
6151 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6154 /* If we are doing the bookkeeping for an element that was
6155 directly output as a constructor, we must update
6156 constructor_unfilled_index. */
6157 constructor_unfilled_index = constructor_index;
6160 /* Handle the sole element allowed in a braced initializer
6161 for a scalar variable. */
6162 else if (constructor_fields == 0)
6164 pedwarn_init ("excess elements in scalar initializer");
6170 output_init_element (value, constructor_type, NULL_TREE, 1);
6171 constructor_fields = 0;
6174 /* Handle range initializers either at this level or anywhere higher
6175 in the designator stack. */
6176 if (constructor_range_stack)
6178 struct constructor_range_stack *p, *range_stack;
6181 range_stack = constructor_range_stack;
6182 constructor_range_stack = 0;
6183 while (constructor_stack != range_stack->stack)
6185 if (!constructor_stack->implicit)
6187 process_init_element (pop_init_level (1));
6189 for (p = range_stack;
6190 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6193 if (!constructor_stack->implicit)
6195 process_init_element (pop_init_level (1));
6198 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6199 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6204 constructor_index = p->index;
6205 constructor_fields = p->fields;
6206 if (finish && p->range_end && p->index == p->range_start)
6214 push_init_level (2);
6215 p->stack = constructor_stack;
6216 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6217 p->index = p->range_start;
6221 constructor_range_stack = range_stack;
6228 constructor_range_stack = 0;
6231 /* Build a simple asm-statement, from one string literal. */
6233 simple_asm_stmt (tree expr)
6237 if (TREE_CODE (expr) == ADDR_EXPR)
6238 expr = TREE_OPERAND (expr, 0);
6240 if (TREE_CODE (expr) == STRING_CST)
6244 /* Simple asm statements are treated as volatile. */
6245 stmt = add_stmt (build_stmt (ASM_STMT, ridpointers[(int) RID_VOLATILE],
6246 expr, NULL_TREE, NULL_TREE, NULL_TREE));
6247 ASM_INPUT_P (stmt) = 1;
6251 error ("argument of `asm' is not a constant string");
6255 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6256 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6259 build_asm_stmt (tree cv_qualifier, tree string, tree outputs, tree inputs,
6264 if (TREE_CODE (string) != STRING_CST)
6266 error ("asm template is not a string constant");
6270 if (cv_qualifier != NULL_TREE
6271 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6273 warning ("%s qualifier ignored on asm",
6274 IDENTIFIER_POINTER (cv_qualifier));
6275 cv_qualifier = NULL_TREE;
6278 /* We can remove output conversions that change the type,
6279 but not the mode. */
6280 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6282 tree output = TREE_VALUE (tail);
6284 STRIP_NOPS (output);
6285 TREE_VALUE (tail) = output;
6287 /* Allow conversions as LHS here. build_modify_expr as called below
6288 will do the right thing with them. */
6289 while (TREE_CODE (output) == NOP_EXPR
6290 || TREE_CODE (output) == CONVERT_EXPR
6291 || TREE_CODE (output) == FLOAT_EXPR
6292 || TREE_CODE (output) == FIX_TRUNC_EXPR
6293 || TREE_CODE (output) == FIX_FLOOR_EXPR
6294 || TREE_CODE (output) == FIX_ROUND_EXPR
6295 || TREE_CODE (output) == FIX_CEIL_EXPR)
6296 output = TREE_OPERAND (output, 0);
6298 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6301 /* Remove output conversions that change the type but not the mode. */
6302 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6304 tree output = TREE_VALUE (tail);
6305 STRIP_NOPS (output);
6306 TREE_VALUE (tail) = output;
6309 /* Perform default conversions on array and function inputs.
6310 Don't do this for other types as it would screw up operands
6311 expected to be in memory. */
6312 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6313 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6315 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6316 outputs, inputs, clobbers));
6319 /* Expand an ASM statement with operands, handling output operands
6320 that are not variables or INDIRECT_REFS by transforming such
6321 cases into cases that expand_asm_operands can handle.
6323 Arguments are same as for expand_asm_operands. */
6326 c_expand_asm_operands (tree string, tree outputs, tree inputs,
6327 tree clobbers, int vol, location_t locus)
6329 int noutputs = list_length (outputs);
6331 /* o[I] is the place that output number I should be written. */
6332 tree *o = alloca (noutputs * sizeof (tree));
6335 /* Record the contents of OUTPUTS before it is modified. */
6336 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6338 o[i] = TREE_VALUE (tail);
6339 if (o[i] == error_mark_node)
6343 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6344 OUTPUTS some trees for where the values were actually stored. */
6345 expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
6347 /* Copy all the intermediate outputs into the specified outputs. */
6348 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6350 if (o[i] != TREE_VALUE (tail))
6352 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6353 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6356 /* Restore the original value so that it's correct the next
6357 time we expand this function. */
6358 TREE_VALUE (tail) = o[i];
6360 /* Detect modification of read-only values.
6361 (Otherwise done by build_modify_expr.) */
6364 tree type = TREE_TYPE (o[i]);
6365 if (TREE_READONLY (o[i])
6366 || TYPE_READONLY (type)
6367 || ((TREE_CODE (type) == RECORD_TYPE
6368 || TREE_CODE (type) == UNION_TYPE)
6369 && C_TYPE_FIELDS_READONLY (type)))
6370 readonly_error (o[i], "modification by `asm'");
6374 /* Those MODIFY_EXPRs could do autoincrements. */
6378 /* Expand a C `return' statement.
6379 RETVAL is the expression for what to return,
6380 or a null pointer for `return;' with no value. */
6383 c_expand_return (tree retval)
6385 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6387 if (TREE_THIS_VOLATILE (current_function_decl))
6388 warning ("function declared `noreturn' has a `return' statement");
6392 current_function_returns_null = 1;
6393 if ((warn_return_type || flag_isoc99)
6394 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6395 pedwarn_c99 ("`return' with no value, in function returning non-void");
6397 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6399 current_function_returns_null = 1;
6400 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6401 pedwarn ("`return' with a value, in function returning void");
6405 tree t = convert_for_assignment (valtype, retval, _("return"),
6406 NULL_TREE, NULL_TREE, 0);
6407 tree res = DECL_RESULT (current_function_decl);
6410 current_function_returns_value = 1;
6411 if (t == error_mark_node)
6414 inner = t = convert (TREE_TYPE (res), t);
6416 /* Strip any conversions, additions, and subtractions, and see if
6417 we are returning the address of a local variable. Warn if so. */
6420 switch (TREE_CODE (inner))
6422 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6424 inner = TREE_OPERAND (inner, 0);
6428 /* If the second operand of the MINUS_EXPR has a pointer
6429 type (or is converted from it), this may be valid, so
6430 don't give a warning. */
6432 tree op1 = TREE_OPERAND (inner, 1);
6434 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6435 && (TREE_CODE (op1) == NOP_EXPR
6436 || TREE_CODE (op1) == NON_LVALUE_EXPR
6437 || TREE_CODE (op1) == CONVERT_EXPR))
6438 op1 = TREE_OPERAND (op1, 0);
6440 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6443 inner = TREE_OPERAND (inner, 0);
6448 inner = TREE_OPERAND (inner, 0);
6450 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6451 inner = TREE_OPERAND (inner, 0);
6453 if (TREE_CODE (inner) == VAR_DECL
6454 && ! DECL_EXTERNAL (inner)
6455 && ! TREE_STATIC (inner)
6456 && DECL_CONTEXT (inner) == current_function_decl)
6457 warning ("function returns address of local variable");
6467 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6470 return add_stmt (build_return_stmt (retval));
6474 /* The SWITCH_STMT being built. */
6476 /* A splay-tree mapping the low element of a case range to the high
6477 element, or NULL_TREE if there is no high element. Used to
6478 determine whether or not a new case label duplicates an old case
6479 label. We need a tree, rather than simply a hash table, because
6480 of the GNU case range extension. */
6482 /* The next node on the stack. */
6483 struct c_switch *next;
6486 /* A stack of the currently active switch statements. The innermost
6487 switch statement is on the top of the stack. There is no need to
6488 mark the stack for garbage collection because it is only active
6489 during the processing of the body of a function, and we never
6490 collect at that point. */
6492 static struct c_switch *switch_stack;
6494 /* Start a C switch statement, testing expression EXP. Return the new
6498 c_start_case (tree exp)
6500 enum tree_code code;
6501 tree type, orig_type = error_mark_node;
6502 struct c_switch *cs;
6504 if (exp != error_mark_node)
6506 code = TREE_CODE (TREE_TYPE (exp));
6507 orig_type = TREE_TYPE (exp);
6509 if (! INTEGRAL_TYPE_P (orig_type)
6510 && code != ERROR_MARK)
6512 error ("switch quantity not an integer");
6513 exp = integer_zero_node;
6517 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6519 if (warn_traditional && !in_system_header
6520 && (type == long_integer_type_node
6521 || type == long_unsigned_type_node))
6522 warning ("`long' switch expression not converted to `int' in ISO C");
6524 exp = default_conversion (exp);
6525 type = TREE_TYPE (exp);
6529 /* Add this new SWITCH_STMT to the stack. */
6530 cs = xmalloc (sizeof (*cs));
6531 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
6532 cs->cases = splay_tree_new (case_compare, NULL, NULL);
6533 cs->next = switch_stack;
6536 return add_stmt (switch_stack->switch_stmt);
6539 /* Process a case label. */
6542 do_case (tree low_value, tree high_value)
6544 tree label = NULL_TREE;
6548 bool switch_was_empty_p = (SWITCH_BODY (switch_stack->switch_stmt) == NULL_TREE);
6550 label = c_add_case_label (switch_stack->cases,
6551 SWITCH_COND (switch_stack->switch_stmt),
6552 low_value, high_value);
6553 if (label == error_mark_node)
6555 else if (switch_was_empty_p)
6557 /* Attach the first case label to the SWITCH_BODY. */
6558 SWITCH_BODY (switch_stack->switch_stmt) = TREE_CHAIN (switch_stack->switch_stmt);
6559 TREE_CHAIN (switch_stack->switch_stmt) = NULL_TREE;
6563 error ("case label not within a switch statement");
6565 error ("`default' label not within a switch statement");
6570 /* Finish the switch statement. */
6573 c_finish_case (void)
6575 struct c_switch *cs = switch_stack;
6577 /* If we've not seen any case labels (or a default), we may still
6578 need to chain any statements that were seen as the SWITCH_BODY. */
6579 if (SWITCH_BODY (cs->switch_stmt) == NULL)
6581 SWITCH_BODY (cs->switch_stmt) = TREE_CHAIN (cs->switch_stmt);
6582 TREE_CHAIN (cs->switch_stmt) = NULL_TREE;
6585 /* Rechain the next statements to the SWITCH_STMT. */
6586 last_tree = cs->switch_stmt;
6588 /* Pop the stack. */
6589 switch_stack = switch_stack->next;
6590 splay_tree_delete (cs->cases);
6594 /* Build a binary-operation expression without default conversions.
6595 CODE is the kind of expression to build.
6596 This function differs from `build' in several ways:
6597 the data type of the result is computed and recorded in it,
6598 warnings are generated if arg data types are invalid,
6599 special handling for addition and subtraction of pointers is known,
6600 and some optimization is done (operations on narrow ints
6601 are done in the narrower type when that gives the same result).
6602 Constant folding is also done before the result is returned.
6604 Note that the operands will never have enumeral types, or function
6605 or array types, because either they will have the default conversions
6606 performed or they have both just been converted to some other type in which
6607 the arithmetic is to be done. */
6610 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6614 enum tree_code code0, code1;
6617 /* Expression code to give to the expression when it is built.
6618 Normally this is CODE, which is what the caller asked for,
6619 but in some special cases we change it. */
6620 enum tree_code resultcode = code;
6622 /* Data type in which the computation is to be performed.
6623 In the simplest cases this is the common type of the arguments. */
6624 tree result_type = NULL;
6626 /* Nonzero means operands have already been type-converted
6627 in whatever way is necessary.
6628 Zero means they need to be converted to RESULT_TYPE. */
6631 /* Nonzero means create the expression with this type, rather than
6633 tree build_type = 0;
6635 /* Nonzero means after finally constructing the expression
6636 convert it to this type. */
6637 tree final_type = 0;
6639 /* Nonzero if this is an operation like MIN or MAX which can
6640 safely be computed in short if both args are promoted shorts.
6641 Also implies COMMON.
6642 -1 indicates a bitwise operation; this makes a difference
6643 in the exact conditions for when it is safe to do the operation
6644 in a narrower mode. */
6647 /* Nonzero if this is a comparison operation;
6648 if both args are promoted shorts, compare the original shorts.
6649 Also implies COMMON. */
6650 int short_compare = 0;
6652 /* Nonzero if this is a right-shift operation, which can be computed on the
6653 original short and then promoted if the operand is a promoted short. */
6654 int short_shift = 0;
6656 /* Nonzero means set RESULT_TYPE to the common type of the args. */
6661 op0 = default_conversion (orig_op0);
6662 op1 = default_conversion (orig_op1);
6670 type0 = TREE_TYPE (op0);
6671 type1 = TREE_TYPE (op1);
6673 /* The expression codes of the data types of the arguments tell us
6674 whether the arguments are integers, floating, pointers, etc. */
6675 code0 = TREE_CODE (type0);
6676 code1 = TREE_CODE (type1);
6678 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
6679 STRIP_TYPE_NOPS (op0);
6680 STRIP_TYPE_NOPS (op1);
6682 /* If an error was already reported for one of the arguments,
6683 avoid reporting another error. */
6685 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6686 return error_mark_node;
6691 /* Handle the pointer + int case. */
6692 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6693 return pointer_int_sum (PLUS_EXPR, op0, op1);
6694 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6695 return pointer_int_sum (PLUS_EXPR, op1, op0);
6701 /* Subtraction of two similar pointers.
6702 We must subtract them as integers, then divide by object size. */
6703 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6704 && comp_target_types (type0, type1, 1))
6705 return pointer_diff (op0, op1);
6706 /* Handle pointer minus int. Just like pointer plus int. */
6707 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6708 return pointer_int_sum (MINUS_EXPR, op0, op1);
6717 case TRUNC_DIV_EXPR:
6719 case FLOOR_DIV_EXPR:
6720 case ROUND_DIV_EXPR:
6721 case EXACT_DIV_EXPR:
6722 /* Floating point division by zero is a legitimate way to obtain
6723 infinities and NaNs. */
6724 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6725 warning ("division by zero");
6727 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6728 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6729 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6730 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6732 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6733 resultcode = RDIV_EXPR;
6735 /* Although it would be tempting to shorten always here, that
6736 loses on some targets, since the modulo instruction is
6737 undefined if the quotient can't be represented in the
6738 computation mode. We shorten only if unsigned or if
6739 dividing by something we know != -1. */
6740 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6741 || (TREE_CODE (op1) == INTEGER_CST
6742 && ! integer_all_onesp (op1)));
6750 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6752 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
6756 case TRUNC_MOD_EXPR:
6757 case FLOOR_MOD_EXPR:
6758 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6759 warning ("division by zero");
6761 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6763 /* Although it would be tempting to shorten always here, that loses
6764 on some targets, since the modulo instruction is undefined if the
6765 quotient can't be represented in the computation mode. We shorten
6766 only if unsigned or if dividing by something we know != -1. */
6767 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6768 || (TREE_CODE (op1) == INTEGER_CST
6769 && ! integer_all_onesp (op1)));
6774 case TRUTH_ANDIF_EXPR:
6775 case TRUTH_ORIF_EXPR:
6776 case TRUTH_AND_EXPR:
6778 case TRUTH_XOR_EXPR:
6779 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
6780 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
6781 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
6782 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
6784 /* Result of these operations is always an int,
6785 but that does not mean the operands should be
6786 converted to ints! */
6787 result_type = integer_type_node;
6788 op0 = c_common_truthvalue_conversion (op0);
6789 op1 = c_common_truthvalue_conversion (op1);
6794 /* Shift operations: result has same type as first operand;
6795 always convert second operand to int.
6796 Also set SHORT_SHIFT if shifting rightward. */
6799 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6801 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6803 if (tree_int_cst_sgn (op1) < 0)
6804 warning ("right shift count is negative");
6807 if (! integer_zerop (op1))
6810 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6811 warning ("right shift count >= width of type");
6815 /* Use the type of the value to be shifted. */
6816 result_type = type0;
6817 /* Convert the shift-count to an integer, regardless of size
6818 of value being shifted. */
6819 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6820 op1 = convert (integer_type_node, op1);
6821 /* Avoid converting op1 to result_type later. */
6827 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6829 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6831 if (tree_int_cst_sgn (op1) < 0)
6832 warning ("left shift count is negative");
6834 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6835 warning ("left shift count >= width of type");
6838 /* Use the type of the value to be shifted. */
6839 result_type = type0;
6840 /* Convert the shift-count to an integer, regardless of size
6841 of value being shifted. */
6842 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6843 op1 = convert (integer_type_node, op1);
6844 /* Avoid converting op1 to result_type later. */
6851 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6853 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6855 if (tree_int_cst_sgn (op1) < 0)
6856 warning ("shift count is negative");
6857 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6858 warning ("shift count >= width of type");
6861 /* Use the type of the value to be shifted. */
6862 result_type = type0;
6863 /* Convert the shift-count to an integer, regardless of size
6864 of value being shifted. */
6865 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6866 op1 = convert (integer_type_node, op1);
6867 /* Avoid converting op1 to result_type later. */
6874 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
6875 warning ("comparing floating point with == or != is unsafe");
6876 /* Result of comparison is always int,
6877 but don't convert the args to int! */
6878 build_type = integer_type_node;
6879 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6880 || code0 == COMPLEX_TYPE)
6881 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6882 || code1 == COMPLEX_TYPE))
6884 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6886 tree tt0 = TREE_TYPE (type0);
6887 tree tt1 = TREE_TYPE (type1);
6888 /* Anything compares with void *. void * compares with anything.
6889 Otherwise, the targets must be compatible
6890 and both must be object or both incomplete. */
6891 if (comp_target_types (type0, type1, 1))
6892 result_type = common_type (type0, type1);
6893 else if (VOID_TYPE_P (tt0))
6895 /* op0 != orig_op0 detects the case of something
6896 whose value is 0 but which isn't a valid null ptr const. */
6897 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
6898 && TREE_CODE (tt1) == FUNCTION_TYPE)
6899 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6901 else if (VOID_TYPE_P (tt1))
6903 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
6904 && TREE_CODE (tt0) == FUNCTION_TYPE)
6905 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6908 pedwarn ("comparison of distinct pointer types lacks a cast");
6910 if (result_type == NULL_TREE)
6911 result_type = ptr_type_node;
6913 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6914 && integer_zerop (op1))
6915 result_type = type0;
6916 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6917 && integer_zerop (op0))
6918 result_type = type1;
6919 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6921 result_type = type0;
6922 pedwarn ("comparison between pointer and integer");
6924 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6926 result_type = type1;
6927 pedwarn ("comparison between pointer and integer");
6933 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6934 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6936 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6938 if (comp_target_types (type0, type1, 1))
6940 result_type = common_type (type0, type1);
6942 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6943 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6947 result_type = ptr_type_node;
6948 pedwarn ("comparison of distinct pointer types lacks a cast");
6957 build_type = integer_type_node;
6958 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6959 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6961 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6963 if (comp_target_types (type0, type1, 1))
6965 result_type = common_type (type0, type1);
6966 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
6967 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
6968 pedwarn ("comparison of complete and incomplete pointers");
6970 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6971 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6975 result_type = ptr_type_node;
6976 pedwarn ("comparison of distinct pointer types lacks a cast");
6979 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6980 && integer_zerop (op1))
6982 result_type = type0;
6983 if (pedantic || extra_warnings)
6984 pedwarn ("ordered comparison of pointer with integer zero");
6986 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6987 && integer_zerop (op0))
6989 result_type = type1;
6991 pedwarn ("ordered comparison of pointer with integer zero");
6993 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6995 result_type = type0;
6996 pedwarn ("comparison between pointer and integer");
6998 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7000 result_type = type1;
7001 pedwarn ("comparison between pointer and integer");
7005 case UNORDERED_EXPR:
7012 build_type = integer_type_node;
7013 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
7015 error ("unordered comparison on non-floating point argument");
7016 return error_mark_node;
7025 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7026 || code0 == VECTOR_TYPE)
7028 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7029 || code1 == VECTOR_TYPE))
7031 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7033 if (shorten || common || short_compare)
7034 result_type = common_type (type0, type1);
7036 /* For certain operations (which identify themselves by shorten != 0)
7037 if both args were extended from the same smaller type,
7038 do the arithmetic in that type and then extend.
7040 shorten !=0 and !=1 indicates a bitwise operation.
7041 For them, this optimization is safe only if
7042 both args are zero-extended or both are sign-extended.
7043 Otherwise, we might change the result.
7044 Eg, (short)-1 | (unsigned short)-1 is (int)-1
7045 but calculated in (unsigned short) it would be (unsigned short)-1. */
7047 if (shorten && none_complex)
7049 int unsigned0, unsigned1;
7050 tree arg0 = get_narrower (op0, &unsigned0);
7051 tree arg1 = get_narrower (op1, &unsigned1);
7052 /* UNS is 1 if the operation to be done is an unsigned one. */
7053 int uns = TREE_UNSIGNED (result_type);
7056 final_type = result_type;
7058 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7059 but it *requires* conversion to FINAL_TYPE. */
7061 if ((TYPE_PRECISION (TREE_TYPE (op0))
7062 == TYPE_PRECISION (TREE_TYPE (arg0)))
7063 && TREE_TYPE (op0) != final_type)
7064 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
7065 if ((TYPE_PRECISION (TREE_TYPE (op1))
7066 == TYPE_PRECISION (TREE_TYPE (arg1)))
7067 && TREE_TYPE (op1) != final_type)
7068 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
7070 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
7072 /* For bitwise operations, signedness of nominal type
7073 does not matter. Consider only how operands were extended. */
7077 /* Note that in all three cases below we refrain from optimizing
7078 an unsigned operation on sign-extended args.
7079 That would not be valid. */
7081 /* Both args variable: if both extended in same way
7082 from same width, do it in that width.
7083 Do it unsigned if args were zero-extended. */
7084 if ((TYPE_PRECISION (TREE_TYPE (arg0))
7085 < TYPE_PRECISION (result_type))
7086 && (TYPE_PRECISION (TREE_TYPE (arg1))
7087 == TYPE_PRECISION (TREE_TYPE (arg0)))
7088 && unsigned0 == unsigned1
7089 && (unsigned0 || !uns))
7091 = c_common_signed_or_unsigned_type
7092 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7093 else if (TREE_CODE (arg0) == INTEGER_CST
7094 && (unsigned1 || !uns)
7095 && (TYPE_PRECISION (TREE_TYPE (arg1))
7096 < TYPE_PRECISION (result_type))
7098 = c_common_signed_or_unsigned_type (unsigned1,
7100 int_fits_type_p (arg0, type)))
7102 else if (TREE_CODE (arg1) == INTEGER_CST
7103 && (unsigned0 || !uns)
7104 && (TYPE_PRECISION (TREE_TYPE (arg0))
7105 < TYPE_PRECISION (result_type))
7107 = c_common_signed_or_unsigned_type (unsigned0,
7109 int_fits_type_p (arg1, type)))
7113 /* Shifts can be shortened if shifting right. */
7118 tree arg0 = get_narrower (op0, &unsigned_arg);
7120 final_type = result_type;
7122 if (arg0 == op0 && final_type == TREE_TYPE (op0))
7123 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
7125 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7126 /* We can shorten only if the shift count is less than the
7127 number of bits in the smaller type size. */
7128 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7129 /* We cannot drop an unsigned shift after sign-extension. */
7130 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
7132 /* Do an unsigned shift if the operand was zero-extended. */
7134 = c_common_signed_or_unsigned_type (unsigned_arg,
7136 /* Convert value-to-be-shifted to that type. */
7137 if (TREE_TYPE (op0) != result_type)
7138 op0 = convert (result_type, op0);
7143 /* Comparison operations are shortened too but differently.
7144 They identify themselves by setting short_compare = 1. */
7148 /* Don't write &op0, etc., because that would prevent op0
7149 from being kept in a register.
7150 Instead, make copies of the our local variables and
7151 pass the copies by reference, then copy them back afterward. */
7152 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7153 enum tree_code xresultcode = resultcode;
7155 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7160 op0 = xop0, op1 = xop1;
7162 resultcode = xresultcode;
7164 if (warn_sign_compare && skip_evaluation == 0)
7166 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
7167 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
7168 int unsignedp0, unsignedp1;
7169 tree primop0 = get_narrower (op0, &unsignedp0);
7170 tree primop1 = get_narrower (op1, &unsignedp1);
7174 STRIP_TYPE_NOPS (xop0);
7175 STRIP_TYPE_NOPS (xop1);
7177 /* Give warnings for comparisons between signed and unsigned
7178 quantities that may fail.
7180 Do the checking based on the original operand trees, so that
7181 casts will be considered, but default promotions won't be.
7183 Do not warn if the comparison is being done in a signed type,
7184 since the signed type will only be chosen if it can represent
7185 all the values of the unsigned type. */
7186 if (! TREE_UNSIGNED (result_type))
7188 /* Do not warn if both operands are the same signedness. */
7189 else if (op0_signed == op1_signed)
7196 sop = xop0, uop = xop1;
7198 sop = xop1, uop = xop0;
7200 /* Do not warn if the signed quantity is an
7201 unsuffixed integer literal (or some static
7202 constant expression involving such literals or a
7203 conditional expression involving such literals)
7204 and it is non-negative. */
7205 if (c_tree_expr_nonnegative_p (sop))
7207 /* Do not warn if the comparison is an equality operation,
7208 the unsigned quantity is an integral constant, and it
7209 would fit in the result if the result were signed. */
7210 else if (TREE_CODE (uop) == INTEGER_CST
7211 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7213 (uop, c_common_signed_type (result_type)))
7215 /* Do not warn if the unsigned quantity is an enumeration
7216 constant and its maximum value would fit in the result
7217 if the result were signed. */
7218 else if (TREE_CODE (uop) == INTEGER_CST
7219 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7221 (TYPE_MAX_VALUE (TREE_TYPE(uop)),
7222 c_common_signed_type (result_type)))
7225 warning ("comparison between signed and unsigned");
7228 /* Warn if two unsigned values are being compared in a size
7229 larger than their original size, and one (and only one) is the
7230 result of a `~' operator. This comparison will always fail.
7232 Also warn if one operand is a constant, and the constant
7233 does not have all bits set that are set in the ~ operand
7234 when it is extended. */
7236 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7237 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7239 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7240 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7243 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7246 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7249 HOST_WIDE_INT constant, mask;
7250 int unsignedp, bits;
7252 if (host_integerp (primop0, 0))
7255 unsignedp = unsignedp1;
7256 constant = tree_low_cst (primop0, 0);
7261 unsignedp = unsignedp0;
7262 constant = tree_low_cst (primop1, 0);
7265 bits = TYPE_PRECISION (TREE_TYPE (primop));
7266 if (bits < TYPE_PRECISION (result_type)
7267 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7269 mask = (~ (HOST_WIDE_INT) 0) << bits;
7270 if ((mask & constant) != mask)
7271 warning ("comparison of promoted ~unsigned with constant");
7274 else if (unsignedp0 && unsignedp1
7275 && (TYPE_PRECISION (TREE_TYPE (primop0))
7276 < TYPE_PRECISION (result_type))
7277 && (TYPE_PRECISION (TREE_TYPE (primop1))
7278 < TYPE_PRECISION (result_type)))
7279 warning ("comparison of promoted ~unsigned with unsigned");
7285 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7286 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7287 Then the expression will be built.
7288 It will be given type FINAL_TYPE if that is nonzero;
7289 otherwise, it will be given type RESULT_TYPE. */
7293 binary_op_error (code);
7294 return error_mark_node;
7299 if (TREE_TYPE (op0) != result_type)
7300 op0 = convert (result_type, op0);
7301 if (TREE_TYPE (op1) != result_type)
7302 op1 = convert (result_type, op1);
7305 if (build_type == NULL_TREE)
7306 build_type = result_type;
7309 tree result = build (resultcode, build_type, op0, op1);
7312 /* Treat expressions in initializers specially as they can't trap. */
7313 folded = require_constant_value ? fold_initializer (result)
7315 if (folded == result)
7316 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
7317 if (final_type != 0)
7318 return convert (final_type, folded);