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 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). */
46 /* Nonzero if we've already printed a "missing braces around initializer"
47 message within this initializer. */
48 static int missing_braces_mentioned;
50 /* 1 if we explained undeclared var errors. */
51 static int undeclared_variable_notice;
53 static tree qualify_type PARAMS ((tree, tree));
54 static int comp_target_types PARAMS ((tree, tree));
55 static int function_types_compatible_p PARAMS ((tree, tree));
56 static int type_lists_compatible_p PARAMS ((tree, tree));
57 static tree decl_constant_value_for_broken_optimization PARAMS ((tree));
58 static tree lookup_field PARAMS ((tree, tree, tree *));
59 static tree convert_arguments PARAMS ((tree, tree, tree, tree));
60 static tree pointer_int_sum PARAMS ((enum tree_code, tree, tree));
61 static tree pointer_diff PARAMS ((tree, tree));
62 static tree unary_complex_lvalue PARAMS ((enum tree_code, tree));
63 static void pedantic_lvalue_warning PARAMS ((enum tree_code));
64 static tree internal_build_compound_expr PARAMS ((tree, int));
65 static tree convert_for_assignment PARAMS ((tree, tree, const char *,
67 static void warn_for_assignment PARAMS ((const char *, const char *,
69 static tree valid_compound_expr_initializer PARAMS ((tree, tree));
70 static void push_string PARAMS ((const char *));
71 static void push_member_name PARAMS ((tree));
72 static void push_array_bounds PARAMS ((int));
73 static int spelling_length PARAMS ((void));
74 static char *print_spelling PARAMS ((char *));
75 static void warning_init PARAMS ((const char *));
76 static tree digest_init PARAMS ((tree, tree, int, int));
77 static void output_init_element PARAMS ((tree, tree, tree, int));
78 static void output_pending_init_elements PARAMS ((int));
79 static int set_designator PARAMS ((int));
80 static void push_range_stack PARAMS ((tree));
81 static void add_pending_init PARAMS ((tree, tree));
82 static void set_nonincremental_init PARAMS ((void));
83 static void set_nonincremental_init_from_string PARAMS ((tree));
84 static tree find_init_member PARAMS ((tree));
86 /* Do `exp = require_complete_type (exp);' to make sure exp
87 does not have an incomplete type. (That includes void types.) */
90 require_complete_type (value)
93 tree type = TREE_TYPE (value);
95 if (TREE_CODE (value) == ERROR_MARK)
96 return error_mark_node;
98 /* First, detect a valid value with a complete type. */
99 if (COMPLETE_TYPE_P (type))
102 incomplete_type_error (value, type);
103 return error_mark_node;
106 /* Print an error message for invalid use of an incomplete type.
107 VALUE is the expression that was used (or 0 if that isn't known)
108 and TYPE is the type that was invalid. */
111 incomplete_type_error (value, 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 type = TREE_TYPE (type);
154 error ("invalid use of array with unspecified bounds");
161 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
162 error ("invalid use of undefined type `%s %s'",
163 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
165 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
166 error ("invalid use of incomplete typedef `%s'",
167 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
171 /* Return a variant of TYPE which has all the type qualifiers of LIKE
172 as well as those of TYPE. */
175 qualify_type (type, like)
178 return c_build_qualified_type (type,
179 TYPE_QUALS (type) | TYPE_QUALS (like));
182 /* Return the common type of two types.
183 We assume that comptypes has already been done and returned 1;
184 if that isn't so, this may crash. In particular, we assume that qualifiers
187 This is the type for the result of most arithmetic operations
188 if the operands have the given two types. */
194 register enum tree_code code1;
195 register enum tree_code code2;
198 /* Save time if the two types are the same. */
200 if (t1 == t2) return t1;
202 /* If one type is nonsense, use the other. */
203 if (t1 == error_mark_node)
205 if (t2 == error_mark_node)
208 /* Merge the attributes. */
209 attributes = (*targetm.merge_type_attributes) (t1, t2);
211 /* Treat an enum type as the unsigned integer type of the same width. */
213 if (TREE_CODE (t1) == ENUMERAL_TYPE)
214 t1 = type_for_size (TYPE_PRECISION (t1), 1);
215 if (TREE_CODE (t2) == ENUMERAL_TYPE)
216 t2 = type_for_size (TYPE_PRECISION (t2), 1);
218 code1 = TREE_CODE (t1);
219 code2 = TREE_CODE (t2);
221 /* If one type is complex, form the common type of the non-complex
222 components, then make that complex. Use T1 or T2 if it is the
224 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
226 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
227 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
228 tree subtype = common_type (subtype1, subtype2);
230 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
231 return build_type_attribute_variant (t1, attributes);
232 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
233 return build_type_attribute_variant (t2, attributes);
235 return build_type_attribute_variant (build_complex_type (subtype),
243 /* If only one is real, use it as the result. */
245 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
246 return build_type_attribute_variant (t1, attributes);
248 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
249 return build_type_attribute_variant (t2, attributes);
251 /* Both real or both integers; use the one with greater precision. */
253 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
254 return build_type_attribute_variant (t1, attributes);
255 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
256 return build_type_attribute_variant (t2, attributes);
258 /* Same precision. Prefer longs to ints even when same size. */
260 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
261 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
262 return build_type_attribute_variant (long_unsigned_type_node,
265 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
266 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
268 /* But preserve unsignedness from the other type,
269 since long cannot hold all the values of an unsigned int. */
270 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
271 t1 = long_unsigned_type_node;
273 t1 = long_integer_type_node;
274 return build_type_attribute_variant (t1, attributes);
277 /* Likewise, prefer long double to double even if same size. */
278 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
279 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
280 return build_type_attribute_variant (long_double_type_node,
283 /* Otherwise prefer the unsigned one. */
285 if (TREE_UNSIGNED (t1))
286 return build_type_attribute_variant (t1, attributes);
288 return build_type_attribute_variant (t2, attributes);
291 /* For two pointers, do this recursively on the target type,
292 and combine the qualifiers of the two types' targets. */
293 /* This code was turned off; I don't know why.
294 But ANSI C specifies doing this with the qualifiers.
295 So I turned it on again. */
297 tree pointed_to_1 = TREE_TYPE (t1);
298 tree pointed_to_2 = TREE_TYPE (t2);
299 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
300 TYPE_MAIN_VARIANT (pointed_to_2));
301 t1 = build_pointer_type (c_build_qualified_type
303 TYPE_QUALS (pointed_to_1) |
304 TYPE_QUALS (pointed_to_2)));
305 return build_type_attribute_variant (t1, attributes);
308 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
309 return build_type_attribute_variant (t1, attributes);
314 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
315 /* Save space: see if the result is identical to one of the args. */
316 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
317 return build_type_attribute_variant (t1, attributes);
318 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
319 return build_type_attribute_variant (t2, attributes);
320 /* Merge the element types, and have a size if either arg has one. */
321 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
322 return build_type_attribute_variant (t1, attributes);
326 /* Function types: prefer the one that specified arg types.
327 If both do, merge the arg types. Also merge the return types. */
329 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
330 tree p1 = TYPE_ARG_TYPES (t1);
331 tree p2 = TYPE_ARG_TYPES (t2);
336 /* Save space: see if the result is identical to one of the args. */
337 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
338 return build_type_attribute_variant (t1, attributes);
339 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
340 return build_type_attribute_variant (t2, attributes);
342 /* Simple way if one arg fails to specify argument types. */
343 if (TYPE_ARG_TYPES (t1) == 0)
345 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
346 return build_type_attribute_variant (t1, attributes);
348 if (TYPE_ARG_TYPES (t2) == 0)
350 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
351 return build_type_attribute_variant (t1, attributes);
354 /* If both args specify argument types, we must merge the two
355 lists, argument by argument. */
358 declare_parm_level (1);
360 len = list_length (p1);
363 for (i = 0; i < len; i++)
364 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
369 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
371 /* A null type means arg type is not specified.
372 Take whatever the other function type has. */
373 if (TREE_VALUE (p1) == 0)
375 TREE_VALUE (n) = TREE_VALUE (p2);
378 if (TREE_VALUE (p2) == 0)
380 TREE_VALUE (n) = TREE_VALUE (p1);
384 /* Given wait (union {union wait *u; int *i} *)
385 and wait (union wait *),
386 prefer union wait * as type of parm. */
387 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
388 && TREE_VALUE (p1) != TREE_VALUE (p2))
391 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
392 memb; memb = TREE_CHAIN (memb))
393 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
395 TREE_VALUE (n) = TREE_VALUE (p2);
397 pedwarn ("function types not truly compatible in ISO C");
401 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
402 && TREE_VALUE (p2) != TREE_VALUE (p1))
405 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
406 memb; memb = TREE_CHAIN (memb))
407 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
409 TREE_VALUE (n) = TREE_VALUE (p1);
411 pedwarn ("function types not truly compatible in ISO C");
415 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
421 t1 = build_function_type (valtype, newargs);
422 /* ... falls through ... */
426 return build_type_attribute_variant (t1, attributes);
431 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
432 or various other operations. Return 2 if they are compatible
433 but a warning may be needed if you use them together. */
436 comptypes (type1, type2)
439 register tree t1 = type1;
440 register tree t2 = type2;
443 /* Suppress errors caused by previously reported errors. */
445 if (t1 == t2 || !t1 || !t2
446 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
449 /* If either type is the internal version of sizetype, return the
451 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
452 && TYPE_DOMAIN (t1) != 0)
453 t1 = TYPE_DOMAIN (t1);
455 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
456 && TYPE_DOMAIN (t2) != 0)
457 t2 = TYPE_DOMAIN (t2);
459 /* Treat an enum type as the integer type of the same width and
462 if (TREE_CODE (t1) == ENUMERAL_TYPE)
463 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
464 if (TREE_CODE (t2) == ENUMERAL_TYPE)
465 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
470 /* Different classes of types can't be compatible. */
472 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
474 /* Qualifiers must match. */
476 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
479 /* Allow for two different type nodes which have essentially the same
480 definition. Note that we already checked for equality of the type
481 qualifiers (just above). */
483 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
486 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
487 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
490 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
493 switch (TREE_CODE (t1))
496 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
497 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
501 val = function_types_compatible_p (t1, t2);
506 tree d1 = TYPE_DOMAIN (t1);
507 tree d2 = TYPE_DOMAIN (t2);
508 bool d1_variable, d2_variable;
509 bool d1_zero, d2_zero;
512 /* Target types must match incl. qualifiers. */
513 if (TREE_TYPE (t1) != TREE_TYPE (t2)
514 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
517 /* Sizes must match unless one is missing or variable. */
518 if (d1 == 0 || d2 == 0 || d1 == d2)
521 d1_zero = ! TYPE_MAX_VALUE (d1);
522 d2_zero = ! TYPE_MAX_VALUE (d2);
524 d1_variable = (! d1_zero
525 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
526 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
527 d2_variable = (! d2_zero
528 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
529 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
531 if (d1_variable || d2_variable)
533 if (d1_zero && d2_zero)
535 if (d1_zero || d2_zero
536 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
537 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
544 if (maybe_objc_comptypes (t1, t2, 0) == 1)
551 return attrval == 2 && val == 1 ? 2 : val;
554 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
555 ignoring their qualifiers. */
558 comp_target_types (ttl, ttr)
563 /* Give maybe_objc_comptypes a crack at letting these types through. */
564 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
567 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
568 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
570 if (val == 2 && pedantic)
571 pedwarn ("types are not quite compatible");
575 /* Subroutines of `comptypes'. */
577 /* Return 1 if two function types F1 and F2 are compatible.
578 If either type specifies no argument types,
579 the other must specify a fixed number of self-promoting arg types.
580 Otherwise, if one type specifies only the number of arguments,
581 the other must specify that number of self-promoting arg types.
582 Otherwise, the argument types must match. */
585 function_types_compatible_p (f1, f2)
589 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
593 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
594 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
597 args1 = TYPE_ARG_TYPES (f1);
598 args2 = TYPE_ARG_TYPES (f2);
600 /* An unspecified parmlist matches any specified parmlist
601 whose argument types don't need default promotions. */
605 if (!self_promoting_args_p (args2))
607 /* If one of these types comes from a non-prototype fn definition,
608 compare that with the other type's arglist.
609 If they don't match, ask for a warning (but no error). */
610 if (TYPE_ACTUAL_ARG_TYPES (f1)
611 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
617 if (!self_promoting_args_p (args1))
619 if (TYPE_ACTUAL_ARG_TYPES (f2)
620 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
625 /* Both types have argument lists: compare them and propagate results. */
626 val1 = type_lists_compatible_p (args1, args2);
627 return val1 != 1 ? val1 : val;
630 /* Check two lists of types for compatibility,
631 returning 0 for incompatible, 1 for compatible,
632 or 2 for compatible with warning. */
635 type_lists_compatible_p (args1, args2)
638 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
644 if (args1 == 0 && args2 == 0)
646 /* If one list is shorter than the other,
647 they fail to match. */
648 if (args1 == 0 || args2 == 0)
650 /* A null pointer instead of a type
651 means there is supposed to be an argument
652 but nothing is specified about what type it has.
653 So match anything that self-promotes. */
654 if (TREE_VALUE (args1) == 0)
656 if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE)
659 else if (TREE_VALUE (args2) == 0)
661 if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE)
664 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
665 TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
667 /* Allow wait (union {union wait *u; int *i} *)
668 and wait (union wait *) to be compatible. */
669 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
670 && (TYPE_NAME (TREE_VALUE (args1)) == 0
671 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
672 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
673 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
674 TYPE_SIZE (TREE_VALUE (args2))))
677 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
678 memb; memb = TREE_CHAIN (memb))
679 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
684 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
685 && (TYPE_NAME (TREE_VALUE (args2)) == 0
686 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
687 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
688 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
689 TYPE_SIZE (TREE_VALUE (args1))))
692 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
693 memb; memb = TREE_CHAIN (memb))
694 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
703 /* comptypes said ok, but record if it said to warn. */
707 args1 = TREE_CHAIN (args1);
708 args2 = TREE_CHAIN (args2);
712 /* Compute the value of the `sizeof' operator. */
718 enum tree_code code = TREE_CODE (type);
721 if (code == FUNCTION_TYPE)
723 if (pedantic || warn_pointer_arith)
724 pedwarn ("sizeof applied to a function type");
725 size = size_one_node;
727 else if (code == VOID_TYPE)
729 if (pedantic || warn_pointer_arith)
730 pedwarn ("sizeof applied to a void type");
731 size = size_one_node;
733 else if (code == ERROR_MARK)
734 size = size_one_node;
735 else if (!COMPLETE_TYPE_P (type))
737 error ("sizeof applied to an incomplete type");
738 size = size_zero_node;
741 /* Convert in case a char is more than one unit. */
742 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
743 size_int (TYPE_PRECISION (char_type_node)
746 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
747 TYPE_IS_SIZETYPE means that certain things (like overflow) will
748 never happen. However, this node should really have type
749 `size_t', which is just a typedef for an ordinary integer type. */
750 return fold (build1 (NOP_EXPR, c_size_type_node, size));
754 c_sizeof_nowarn (type)
757 enum tree_code code = TREE_CODE (type);
760 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
761 size = size_one_node;
762 else if (!COMPLETE_TYPE_P (type))
763 size = size_zero_node;
765 /* Convert in case a char is more than one unit. */
766 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
767 size_int (TYPE_PRECISION (char_type_node)
770 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
771 TYPE_IS_SIZETYPE means that certain things (like overflow) will
772 never happen. However, this node should really have type
773 `size_t', which is just a typedef for an ordinary integer type. */
774 return fold (build1 (NOP_EXPR, c_size_type_node, size));
777 /* Compute the size to increment a pointer by. */
780 c_size_in_bytes (type)
783 enum tree_code code = TREE_CODE (type);
785 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
786 return size_one_node;
788 if (!COMPLETE_OR_VOID_TYPE_P (type))
790 error ("arithmetic on pointer to an incomplete type");
791 return size_one_node;
794 /* Convert in case a char is more than one unit. */
795 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
796 size_int (TYPE_PRECISION (char_type_node)
800 /* Return either DECL or its known constant value (if it has one). */
803 decl_constant_value (decl)
806 if (/* Don't change a variable array bound or initial value to a constant
807 in a place where a variable is invalid. */
808 current_function_decl != 0
809 && ! TREE_THIS_VOLATILE (decl)
810 && TREE_READONLY (decl)
811 && DECL_INITIAL (decl) != 0
812 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
813 /* This is invalid if initial value is not constant.
814 If it has either a function call, a memory reference,
815 or a variable, then re-evaluating it could give different results. */
816 && TREE_CONSTANT (DECL_INITIAL (decl))
817 /* Check for cases where this is sub-optimal, even though valid. */
818 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
819 return DECL_INITIAL (decl);
823 /* Return either DECL or its known constant value (if it has one), but
824 return DECL if pedantic or DECL has mode BLKmode. This is for
825 bug-compatibility with the old behavior of decl_constant_value
826 (before GCC 3.0); every use of this function is a bug and it should
827 be removed before GCC 3.1. It is not appropriate to use pedantic
828 in a way that affects optimization, and BLKmode is probably not the
829 right test for avoiding misoptimizations either. */
832 decl_constant_value_for_broken_optimization (decl)
835 if (pedantic || DECL_MODE (decl) == BLKmode)
838 return decl_constant_value (decl);
841 /* Perform default promotions for C data used in expressions.
842 Arrays and functions are converted to pointers;
843 enumeral types or short or char, to int.
844 In addition, manifest constants symbols are replaced by their values. */
847 default_conversion (exp)
850 register tree type = TREE_TYPE (exp);
851 register enum tree_code code = TREE_CODE (type);
853 /* Constants can be used directly unless they're not loadable. */
854 if (TREE_CODE (exp) == CONST_DECL)
855 exp = DECL_INITIAL (exp);
857 /* Replace a nonvolatile const static variable with its value unless
858 it is an array, in which case we must be sure that taking the
859 address of the array produces consistent results. */
860 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
862 exp = decl_constant_value_for_broken_optimization (exp);
863 type = TREE_TYPE (exp);
866 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
869 Do not use STRIP_NOPS here! It will remove conversions from pointer
870 to integer and cause infinite recursion. */
871 while (TREE_CODE (exp) == NON_LVALUE_EXPR
872 || (TREE_CODE (exp) == NOP_EXPR
873 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
874 exp = TREE_OPERAND (exp, 0);
876 /* Normally convert enums to int,
877 but convert wide enums to something wider. */
878 if (code == ENUMERAL_TYPE)
880 type = type_for_size (MAX (TYPE_PRECISION (type),
881 TYPE_PRECISION (integer_type_node)),
883 || (TYPE_PRECISION (type)
884 >= TYPE_PRECISION (integer_type_node)))
885 && TREE_UNSIGNED (type)));
887 return convert (type, exp);
890 if (TREE_CODE (exp) == COMPONENT_REF
891 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
892 /* If it's thinner than an int, promote it like a
893 c_promoting_integer_type_p, otherwise leave it alone. */
894 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
895 TYPE_PRECISION (integer_type_node)))
896 return convert (flag_traditional && TREE_UNSIGNED (type)
897 ? unsigned_type_node : integer_type_node,
900 if (c_promoting_integer_type_p (type))
902 /* Traditionally, unsignedness is preserved in default promotions.
903 Also preserve unsignedness if not really getting any wider. */
904 if (TREE_UNSIGNED (type)
906 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
907 return convert (unsigned_type_node, exp);
909 return convert (integer_type_node, exp);
912 if (flag_traditional && !flag_allow_single_precision
913 && TYPE_MAIN_VARIANT (type) == float_type_node)
914 return convert (double_type_node, exp);
916 if (code == VOID_TYPE)
918 error ("void value not ignored as it ought to be");
919 return error_mark_node;
921 if (code == FUNCTION_TYPE)
923 return build_unary_op (ADDR_EXPR, exp, 0);
925 if (code == ARRAY_TYPE)
928 tree restype = TREE_TYPE (type);
933 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
935 constp = TREE_READONLY (exp);
936 volatilep = TREE_THIS_VOLATILE (exp);
939 if (TYPE_QUALS (type) || constp || volatilep)
941 = c_build_qualified_type (restype,
943 | (constp * TYPE_QUAL_CONST)
944 | (volatilep * TYPE_QUAL_VOLATILE));
946 if (TREE_CODE (exp) == INDIRECT_REF)
947 return convert (TYPE_POINTER_TO (restype),
948 TREE_OPERAND (exp, 0));
950 if (TREE_CODE (exp) == COMPOUND_EXPR)
952 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
953 return build (COMPOUND_EXPR, TREE_TYPE (op1),
954 TREE_OPERAND (exp, 0), op1);
958 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
960 error ("invalid use of non-lvalue array");
961 return error_mark_node;
964 ptrtype = build_pointer_type (restype);
966 if (TREE_CODE (exp) == VAR_DECL)
968 /* ??? This is not really quite correct
969 in that the type of the operand of ADDR_EXPR
970 is not the target type of the type of the ADDR_EXPR itself.
971 Question is, can this lossage be avoided? */
972 adr = build1 (ADDR_EXPR, ptrtype, exp);
973 if (mark_addressable (exp) == 0)
974 return error_mark_node;
975 TREE_CONSTANT (adr) = staticp (exp);
976 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
979 /* This way is better for a COMPONENT_REF since it can
980 simplify the offset for a component. */
981 adr = build_unary_op (ADDR_EXPR, exp, 1);
982 return convert (ptrtype, adr);
987 /* Look up component name in the structure type definition.
989 If this component name is found indirectly within an anonymous union,
990 store in *INDIRECT the component which directly contains
991 that anonymous union. Otherwise, set *INDIRECT to 0. */
994 lookup_field (type, component, indirect)
995 tree type, component;
1000 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1001 to the field elements. Use a binary search on this array to quickly
1002 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1003 will always be set for structures which have many elements. */
1005 if (TYPE_LANG_SPECIFIC (type))
1008 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1010 field = TYPE_FIELDS (type);
1012 top = TYPE_LANG_SPECIFIC (type)->len;
1013 while (top - bot > 1)
1015 half = (top - bot + 1) >> 1;
1016 field = field_array[bot+half];
1018 if (DECL_NAME (field) == NULL_TREE)
1020 /* Step through all anon unions in linear fashion. */
1021 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1023 tree anon = 0, junk;
1025 field = field_array[bot++];
1026 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1027 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1028 anon = lookup_field (TREE_TYPE (field), component, &junk);
1030 if (anon != NULL_TREE)
1037 /* Entire record is only anon unions. */
1041 /* Restart the binary search, with new lower bound. */
1045 if (DECL_NAME (field) == component)
1047 if (DECL_NAME (field) < component)
1053 if (DECL_NAME (field_array[bot]) == component)
1054 field = field_array[bot];
1055 else if (DECL_NAME (field) != component)
1060 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1062 if (DECL_NAME (field) == NULL_TREE)
1067 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1068 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1069 anon = lookup_field (TREE_TYPE (field), component, &junk);
1071 if (anon != NULL_TREE)
1078 if (DECL_NAME (field) == component)
1083 *indirect = NULL_TREE;
1087 /* Make an expression to refer to the COMPONENT field of
1088 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1091 build_component_ref (datum, component)
1092 tree datum, component;
1094 register tree type = TREE_TYPE (datum);
1095 register enum tree_code code = TREE_CODE (type);
1096 register tree field = NULL;
1099 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1100 unless we are not to support things not strictly ANSI. */
1101 switch (TREE_CODE (datum))
1105 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1106 return build (COMPOUND_EXPR, TREE_TYPE (value),
1107 TREE_OPERAND (datum, 0), value);
1110 return build_conditional_expr
1111 (TREE_OPERAND (datum, 0),
1112 build_component_ref (TREE_OPERAND (datum, 1), component),
1113 build_component_ref (TREE_OPERAND (datum, 2), component));
1119 /* See if there is a field or component with name COMPONENT. */
1121 if (code == RECORD_TYPE || code == UNION_TYPE)
1125 if (!COMPLETE_TYPE_P (type))
1127 incomplete_type_error (NULL_TREE, type);
1128 return error_mark_node;
1131 field = lookup_field (type, component, &indirect);
1135 error ("%s has no member named `%s'",
1136 code == RECORD_TYPE ? "structure" : "union",
1137 IDENTIFIER_POINTER (component));
1138 return error_mark_node;
1140 if (TREE_TYPE (field) == error_mark_node)
1141 return error_mark_node;
1143 /* If FIELD was found buried within an anonymous union,
1144 make one COMPONENT_REF to get that anonymous union,
1145 then fall thru to make a second COMPONENT_REF to get FIELD. */
1148 ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1149 if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1150 TREE_READONLY (ref) = 1;
1151 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1152 TREE_THIS_VOLATILE (ref) = 1;
1156 ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1158 if (TREE_READONLY (datum) || TREE_READONLY (field))
1159 TREE_READONLY (ref) = 1;
1160 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1161 TREE_THIS_VOLATILE (ref) = 1;
1165 else if (code != ERROR_MARK)
1166 error ("request for member `%s' in something not a structure or union",
1167 IDENTIFIER_POINTER (component));
1169 return error_mark_node;
1172 /* Given an expression PTR for a pointer, return an expression
1173 for the value pointed to.
1174 ERRORSTRING is the name of the operator to appear in error messages. */
1177 build_indirect_ref (ptr, errorstring)
1179 const char *errorstring;
1181 register tree pointer = default_conversion (ptr);
1182 register tree type = TREE_TYPE (pointer);
1184 if (TREE_CODE (type) == POINTER_TYPE)
1186 if (TREE_CODE (pointer) == ADDR_EXPR
1188 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1189 == TREE_TYPE (type)))
1190 return TREE_OPERAND (pointer, 0);
1193 tree t = TREE_TYPE (type);
1194 register tree ref = build1 (INDIRECT_REF,
1195 TYPE_MAIN_VARIANT (t), pointer);
1197 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1199 error ("dereferencing pointer to incomplete type");
1200 return error_mark_node;
1202 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1203 warning ("dereferencing `void *' pointer");
1205 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1206 so that we get the proper error message if the result is used
1207 to assign to. Also, &* is supposed to be a no-op.
1208 And ANSI C seems to specify that the type of the result
1209 should be the const type. */
1210 /* A de-reference of a pointer to const is not a const. It is valid
1211 to change it via some other pointer. */
1212 TREE_READONLY (ref) = TYPE_READONLY (t);
1213 TREE_SIDE_EFFECTS (ref)
1214 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1215 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1219 else if (TREE_CODE (pointer) != ERROR_MARK)
1220 error ("invalid type argument of `%s'", errorstring);
1221 return error_mark_node;
1224 /* This handles expressions of the form "a[i]", which denotes
1227 This is logically equivalent in C to *(a+i), but we may do it differently.
1228 If A is a variable or a member, we generate a primitive ARRAY_REF.
1229 This avoids forcing the array out of registers, and can work on
1230 arrays that are not lvalues (for example, members of structures returned
1234 build_array_ref (array, index)
1239 error ("subscript missing in array reference");
1240 return error_mark_node;
1243 if (TREE_TYPE (array) == error_mark_node
1244 || TREE_TYPE (index) == error_mark_node)
1245 return error_mark_node;
1247 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1248 && TREE_CODE (array) != INDIRECT_REF)
1252 /* Subscripting with type char is likely to lose
1253 on a machine where chars are signed.
1254 So warn on any machine, but optionally.
1255 Don't warn for unsigned char since that type is safe.
1256 Don't warn for signed char because anyone who uses that
1257 must have done so deliberately. */
1258 if (warn_char_subscripts
1259 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1260 warning ("array subscript has type `char'");
1262 /* Apply default promotions *after* noticing character types. */
1263 index = default_conversion (index);
1265 /* Require integer *after* promotion, for sake of enums. */
1266 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1268 error ("array subscript is not an integer");
1269 return error_mark_node;
1272 /* An array that is indexed by a non-constant
1273 cannot be stored in a register; we must be able to do
1274 address arithmetic on its address.
1275 Likewise an array of elements of variable size. */
1276 if (TREE_CODE (index) != INTEGER_CST
1277 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1278 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1280 if (mark_addressable (array) == 0)
1281 return error_mark_node;
1283 /* An array that is indexed by a constant value which is not within
1284 the array bounds cannot be stored in a register either; because we
1285 would get a crash in store_bit_field/extract_bit_field when trying
1286 to access a non-existent part of the register. */
1287 if (TREE_CODE (index) == INTEGER_CST
1288 && TYPE_VALUES (TREE_TYPE (array))
1289 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1291 if (mark_addressable (array) == 0)
1292 return error_mark_node;
1298 while (TREE_CODE (foo) == COMPONENT_REF)
1299 foo = TREE_OPERAND (foo, 0);
1300 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1301 pedwarn ("ISO C forbids subscripting `register' array");
1302 else if (! flag_isoc99 && ! lvalue_p (foo))
1303 pedwarn ("ISO C89 forbids subscripting non-lvalue array");
1306 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1307 rval = build (ARRAY_REF, type, array, index);
1308 /* Array ref is const/volatile if the array elements are
1309 or if the array is. */
1310 TREE_READONLY (rval)
1311 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1312 | TREE_READONLY (array));
1313 TREE_SIDE_EFFECTS (rval)
1314 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1315 | TREE_SIDE_EFFECTS (array));
1316 TREE_THIS_VOLATILE (rval)
1317 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1318 /* This was added by rms on 16 Nov 91.
1319 It fixes vol struct foo *a; a->elts[1]
1320 in an inline function.
1321 Hope it doesn't break something else. */
1322 | TREE_THIS_VOLATILE (array));
1323 return require_complete_type (fold (rval));
1327 tree ar = default_conversion (array);
1328 tree ind = default_conversion (index);
1330 /* Do the same warning check as above, but only on the part that's
1331 syntactically the index and only if it is also semantically
1333 if (warn_char_subscripts
1334 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1335 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1336 warning ("subscript has type `char'");
1338 /* Put the integer in IND to simplify error checking. */
1339 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1346 if (ar == error_mark_node)
1349 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1350 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1352 error ("subscripted value is neither array nor pointer");
1353 return error_mark_node;
1355 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1357 error ("array subscript is not an integer");
1358 return error_mark_node;
1361 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1366 /* Build an external reference to identifier ID. FUN indicates
1367 whether this will be used for a function call. */
1369 build_external_ref (id, fun)
1374 tree decl = lookup_name (id);
1375 tree objc_ivar = lookup_objc_ivar (id);
1377 if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
1383 if (!decl || decl == error_mark_node)
1384 /* Ordinary implicit function declaration. */
1385 ref = implicitly_declare (id);
1388 /* Implicit declaration of built-in function. Don't
1389 change the built-in declaration, but don't let this
1390 go by silently, either. */
1391 implicit_decl_warning (id);
1393 /* only issue this warning once */
1394 C_DECL_ANTICIPATED (decl) = 0;
1400 /* Reference to undeclared variable, including reference to
1401 builtin outside of function-call context. */
1402 if (current_function_decl == 0)
1403 error ("`%s' undeclared here (not in a function)",
1404 IDENTIFIER_POINTER (id));
1407 if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node
1408 || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl)
1410 error ("`%s' undeclared (first use in this function)",
1411 IDENTIFIER_POINTER (id));
1413 if (! undeclared_variable_notice)
1415 error ("(Each undeclared identifier is reported only once");
1416 error ("for each function it appears in.)");
1417 undeclared_variable_notice = 1;
1420 IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node;
1421 IDENTIFIER_ERROR_LOCUS (id) = current_function_decl;
1423 return error_mark_node;
1428 /* Properly declared variable or function reference. */
1431 else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
1433 warning ("local declaration of `%s' hides instance variable",
1434 IDENTIFIER_POINTER (id));
1441 if (TREE_TYPE (ref) == error_mark_node)
1442 return error_mark_node;
1444 assemble_external (ref);
1445 TREE_USED (ref) = 1;
1447 if (TREE_CODE (ref) == CONST_DECL)
1449 ref = DECL_INITIAL (ref);
1450 TREE_CONSTANT (ref) = 1;
1456 /* Build a function call to function FUNCTION with parameters PARAMS.
1457 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1458 TREE_VALUE of each node is a parameter-expression.
1459 FUNCTION's data type may be a function type or a pointer-to-function. */
1462 build_function_call (function, params)
1463 tree function, params;
1465 register tree fntype, fundecl = 0;
1466 register tree coerced_params;
1467 tree name = NULL_TREE, assembler_name = NULL_TREE, result;
1469 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1470 STRIP_TYPE_NOPS (function);
1472 /* Convert anything with function type to a pointer-to-function. */
1473 if (TREE_CODE (function) == FUNCTION_DECL)
1475 name = DECL_NAME (function);
1476 assembler_name = DECL_ASSEMBLER_NAME (function);
1478 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1479 (because calling an inline function does not mean the function
1480 needs to be separately compiled). */
1481 fntype = build_type_variant (TREE_TYPE (function),
1482 TREE_READONLY (function),
1483 TREE_THIS_VOLATILE (function));
1485 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1488 function = default_conversion (function);
1490 fntype = TREE_TYPE (function);
1492 if (TREE_CODE (fntype) == ERROR_MARK)
1493 return error_mark_node;
1495 if (!(TREE_CODE (fntype) == POINTER_TYPE
1496 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1498 error ("called object is not a function");
1499 return error_mark_node;
1502 /* fntype now gets the type of function pointed to. */
1503 fntype = TREE_TYPE (fntype);
1505 /* Convert the parameters to the types declared in the
1506 function prototype, or apply default promotions. */
1509 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1511 /* Check for errors in format strings. */
1514 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
1516 /* Recognize certain built-in functions so we can make tree-codes
1517 other than CALL_EXPR. We do this when it enables fold-const.c
1518 to do something useful. */
1520 if (TREE_CODE (function) == ADDR_EXPR
1521 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1522 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1524 result = expand_tree_builtin (TREE_OPERAND (function, 0),
1525 params, coerced_params);
1530 result = build (CALL_EXPR, TREE_TYPE (fntype),
1531 function, coerced_params, NULL_TREE);
1532 TREE_SIDE_EFFECTS (result) = 1;
1533 result = fold (result);
1535 if (VOID_TYPE_P (TREE_TYPE (result)))
1537 return require_complete_type (result);
1540 /* Convert the argument expressions in the list VALUES
1541 to the types in the list TYPELIST. The result is a list of converted
1542 argument expressions.
1544 If TYPELIST is exhausted, or when an element has NULL as its type,
1545 perform the default conversions.
1547 PARMLIST is the chain of parm decls for the function being called.
1548 It may be 0, if that info is not available.
1549 It is used only for generating error messages.
1551 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1553 This is also where warnings about wrong number of args are generated.
1555 Both VALUES and the returned value are chains of TREE_LIST nodes
1556 with the elements of the list in the TREE_VALUE slots of those nodes. */
1559 convert_arguments (typelist, values, name, fundecl)
1560 tree typelist, values, name, fundecl;
1562 register tree typetail, valtail;
1563 register tree result = NULL;
1566 /* Scan the given expressions and types, producing individual
1567 converted arguments and pushing them on RESULT in reverse order. */
1569 for (valtail = values, typetail = typelist, parmnum = 0;
1571 valtail = TREE_CHAIN (valtail), parmnum++)
1573 register tree type = typetail ? TREE_VALUE (typetail) : 0;
1574 register tree val = TREE_VALUE (valtail);
1576 if (type == void_type_node)
1579 error ("too many arguments to function `%s'",
1580 IDENTIFIER_POINTER (name));
1582 error ("too many arguments to function");
1586 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1587 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1588 to convert automatically to a pointer. */
1589 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1590 val = TREE_OPERAND (val, 0);
1592 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1593 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1594 val = default_conversion (val);
1596 val = require_complete_type (val);
1600 /* Formal parm type is specified by a function prototype. */
1603 if (!COMPLETE_TYPE_P (type))
1605 error ("type of formal parameter %d is incomplete", parmnum + 1);
1610 /* Optionally warn about conversions that
1611 differ from the default conversions. */
1612 if (warn_conversion || warn_traditional)
1614 int formal_prec = TYPE_PRECISION (type);
1616 if (INTEGRAL_TYPE_P (type)
1617 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1618 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1619 if (INTEGRAL_TYPE_P (type)
1620 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1621 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1622 else if (TREE_CODE (type) == COMPLEX_TYPE
1623 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1624 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1625 else if (TREE_CODE (type) == REAL_TYPE
1626 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1627 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1628 else if (TREE_CODE (type) == COMPLEX_TYPE
1629 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1630 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1631 else if (TREE_CODE (type) == REAL_TYPE
1632 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1633 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1634 /* ??? At some point, messages should be written about
1635 conversions between complex types, but that's too messy
1637 else if (TREE_CODE (type) == REAL_TYPE
1638 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1640 /* Warn if any argument is passed as `float',
1641 since without a prototype it would be `double'. */
1642 if (formal_prec == TYPE_PRECISION (float_type_node))
1643 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1645 /* Detect integer changing in width or signedness.
1646 These warnings are only activated with
1647 -Wconversion, not with -Wtraditional. */
1648 else if (warn_conversion && INTEGRAL_TYPE_P (type)
1649 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1651 tree would_have_been = default_conversion (val);
1652 tree type1 = TREE_TYPE (would_have_been);
1654 if (TREE_CODE (type) == ENUMERAL_TYPE
1655 && type == TREE_TYPE (val))
1656 /* No warning if function asks for enum
1657 and the actual arg is that enum type. */
1659 else if (formal_prec != TYPE_PRECISION (type1))
1660 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1661 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1663 /* Don't complain if the formal parameter type
1664 is an enum, because we can't tell now whether
1665 the value was an enum--even the same enum. */
1666 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1668 else if (TREE_CODE (val) == INTEGER_CST
1669 && int_fits_type_p (val, type))
1670 /* Change in signedness doesn't matter
1671 if a constant value is unaffected. */
1673 /* Likewise for a constant in a NOP_EXPR. */
1674 else if (TREE_CODE (val) == NOP_EXPR
1675 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1676 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1678 #if 0 /* We never get such tree structure here. */
1679 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1680 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1681 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1682 /* Change in signedness doesn't matter
1683 if an enum value is unaffected. */
1686 /* If the value is extended from a narrower
1687 unsigned type, it doesn't matter whether we
1688 pass it as signed or unsigned; the value
1689 certainly is the same either way. */
1690 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1691 && TREE_UNSIGNED (TREE_TYPE (val)))
1693 else if (TREE_UNSIGNED (type))
1694 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1696 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1700 parmval = convert_for_assignment (type, val,
1701 (char *) 0, /* arg passing */
1702 fundecl, name, parmnum + 1);
1704 if (PROMOTE_PROTOTYPES
1705 && INTEGRAL_TYPE_P (type)
1706 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1707 parmval = default_conversion (parmval);
1709 result = tree_cons (NULL_TREE, parmval, result);
1711 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1712 && (TYPE_PRECISION (TREE_TYPE (val))
1713 < TYPE_PRECISION (double_type_node)))
1714 /* Convert `float' to `double'. */
1715 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1717 /* Convert `short' and `char' to full-size `int'. */
1718 result = tree_cons (NULL_TREE, default_conversion (val), result);
1721 typetail = TREE_CHAIN (typetail);
1724 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1727 error ("too few arguments to function `%s'",
1728 IDENTIFIER_POINTER (name));
1730 error ("too few arguments to function");
1733 return nreverse (result);
1736 /* This is the entry point used by the parser
1737 for binary operators in the input.
1738 In addition to constructing the expression,
1739 we check for operands that were written with other binary operators
1740 in a way that is likely to confuse the user. */
1743 parser_build_binary_op (code, arg1, arg2)
1744 enum tree_code code;
1747 tree result = build_binary_op (code, arg1, arg2, 1);
1750 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1751 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1752 enum tree_code code1 = ERROR_MARK;
1753 enum tree_code code2 = ERROR_MARK;
1755 if (class1 == 'e' || class1 == '1'
1756 || class1 == '2' || class1 == '<')
1757 code1 = C_EXP_ORIGINAL_CODE (arg1);
1758 if (class2 == 'e' || class2 == '1'
1759 || class2 == '2' || class2 == '<')
1760 code2 = C_EXP_ORIGINAL_CODE (arg2);
1762 /* Check for cases such as x+y<<z which users are likely
1763 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1764 is cleared to prevent these warnings. */
1765 if (warn_parentheses)
1767 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1769 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1770 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1771 warning ("suggest parentheses around + or - inside shift");
1774 if (code == TRUTH_ORIF_EXPR)
1776 if (code1 == TRUTH_ANDIF_EXPR
1777 || code2 == TRUTH_ANDIF_EXPR)
1778 warning ("suggest parentheses around && within ||");
1781 if (code == BIT_IOR_EXPR)
1783 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1784 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1785 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1786 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1787 warning ("suggest parentheses around arithmetic in operand of |");
1788 /* Check cases like x|y==z */
1789 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1790 warning ("suggest parentheses around comparison in operand of |");
1793 if (code == BIT_XOR_EXPR)
1795 if (code1 == BIT_AND_EXPR
1796 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1797 || code2 == BIT_AND_EXPR
1798 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1799 warning ("suggest parentheses around arithmetic in operand of ^");
1800 /* Check cases like x^y==z */
1801 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1802 warning ("suggest parentheses around comparison in operand of ^");
1805 if (code == BIT_AND_EXPR)
1807 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1808 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1809 warning ("suggest parentheses around + or - in operand of &");
1810 /* Check cases like x&y==z */
1811 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1812 warning ("suggest parentheses around comparison in operand of &");
1816 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1817 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1818 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1819 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1821 unsigned_conversion_warning (result, arg1);
1822 unsigned_conversion_warning (result, arg2);
1823 overflow_warning (result);
1825 class = TREE_CODE_CLASS (TREE_CODE (result));
1827 /* Record the code that was specified in the source,
1828 for the sake of warnings about confusing nesting. */
1829 if (class == 'e' || class == '1'
1830 || class == '2' || class == '<')
1831 C_SET_EXP_ORIGINAL_CODE (result, code);
1834 int flag = TREE_CONSTANT (result);
1835 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1836 so that convert_for_assignment wouldn't strip it.
1837 That way, we got warnings for things like p = (1 - 1).
1838 But it turns out we should not get those warnings. */
1839 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1840 C_SET_EXP_ORIGINAL_CODE (result, code);
1841 TREE_CONSTANT (result) = flag;
1847 /* Build a binary-operation expression without default conversions.
1848 CODE is the kind of expression to build.
1849 This function differs from `build' in several ways:
1850 the data type of the result is computed and recorded in it,
1851 warnings are generated if arg data types are invalid,
1852 special handling for addition and subtraction of pointers is known,
1853 and some optimization is done (operations on narrow ints
1854 are done in the narrower type when that gives the same result).
1855 Constant folding is also done before the result is returned.
1857 Note that the operands will never have enumeral types, or function
1858 or array types, because either they will have the default conversions
1859 performed or they have both just been converted to some other type in which
1860 the arithmetic is to be done. */
1863 build_binary_op (code, orig_op0, orig_op1, convert_p)
1864 enum tree_code code;
1865 tree orig_op0, orig_op1;
1869 register enum tree_code code0, code1;
1872 /* Expression code to give to the expression when it is built.
1873 Normally this is CODE, which is what the caller asked for,
1874 but in some special cases we change it. */
1875 register enum tree_code resultcode = code;
1877 /* Data type in which the computation is to be performed.
1878 In the simplest cases this is the common type of the arguments. */
1879 register tree result_type = NULL;
1881 /* Nonzero means operands have already been type-converted
1882 in whatever way is necessary.
1883 Zero means they need to be converted to RESULT_TYPE. */
1886 /* Nonzero means create the expression with this type, rather than
1888 tree build_type = 0;
1890 /* Nonzero means after finally constructing the expression
1891 convert it to this type. */
1892 tree final_type = 0;
1894 /* Nonzero if this is an operation like MIN or MAX which can
1895 safely be computed in short if both args are promoted shorts.
1896 Also implies COMMON.
1897 -1 indicates a bitwise operation; this makes a difference
1898 in the exact conditions for when it is safe to do the operation
1899 in a narrower mode. */
1902 /* Nonzero if this is a comparison operation;
1903 if both args are promoted shorts, compare the original shorts.
1904 Also implies COMMON. */
1905 int short_compare = 0;
1907 /* Nonzero if this is a right-shift operation, which can be computed on the
1908 original short and then promoted if the operand is a promoted short. */
1909 int short_shift = 0;
1911 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1916 op0 = default_conversion (orig_op0);
1917 op1 = default_conversion (orig_op1);
1925 type0 = TREE_TYPE (op0);
1926 type1 = TREE_TYPE (op1);
1928 /* The expression codes of the data types of the arguments tell us
1929 whether the arguments are integers, floating, pointers, etc. */
1930 code0 = TREE_CODE (type0);
1931 code1 = TREE_CODE (type1);
1933 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1934 STRIP_TYPE_NOPS (op0);
1935 STRIP_TYPE_NOPS (op1);
1937 /* If an error was already reported for one of the arguments,
1938 avoid reporting another error. */
1940 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
1941 return error_mark_node;
1946 /* Handle the pointer + int case. */
1947 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1948 return pointer_int_sum (PLUS_EXPR, op0, op1);
1949 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
1950 return pointer_int_sum (PLUS_EXPR, op1, op0);
1956 /* Subtraction of two similar pointers.
1957 We must subtract them as integers, then divide by object size. */
1958 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
1959 && comp_target_types (type0, type1))
1960 return pointer_diff (op0, op1);
1961 /* Handle pointer minus int. Just like pointer plus int. */
1962 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1963 return pointer_int_sum (MINUS_EXPR, op0, op1);
1972 case TRUNC_DIV_EXPR:
1974 case FLOOR_DIV_EXPR:
1975 case ROUND_DIV_EXPR:
1976 case EXACT_DIV_EXPR:
1977 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
1978 || code0 == COMPLEX_TYPE)
1979 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
1980 || code1 == COMPLEX_TYPE))
1982 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
1983 resultcode = RDIV_EXPR;
1985 /* Although it would be tempting to shorten always here, that
1986 loses on some targets, since the modulo instruction is
1987 undefined if the quotient can't be represented in the
1988 computation mode. We shorten only if unsigned or if
1989 dividing by something we know != -1. */
1990 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
1991 || (TREE_CODE (op1) == INTEGER_CST
1992 && ! integer_all_onesp (op1)));
1998 case BIT_ANDTC_EXPR:
2001 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2003 /* If one operand is a constant, and the other is a short type
2004 that has been converted to an int,
2005 really do the work in the short type and then convert the
2006 result to int. If we are lucky, the constant will be 0 or 1
2007 in the short type, making the entire operation go away. */
2008 if (TREE_CODE (op0) == INTEGER_CST
2009 && TREE_CODE (op1) == NOP_EXPR
2010 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2011 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2013 final_type = result_type;
2014 op1 = TREE_OPERAND (op1, 0);
2015 result_type = TREE_TYPE (op1);
2017 if (TREE_CODE (op1) == INTEGER_CST
2018 && TREE_CODE (op0) == NOP_EXPR
2019 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2020 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2022 final_type = result_type;
2023 op0 = TREE_OPERAND (op0, 0);
2024 result_type = TREE_TYPE (op0);
2028 case TRUNC_MOD_EXPR:
2029 case FLOOR_MOD_EXPR:
2030 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2032 /* Although it would be tempting to shorten always here, that loses
2033 on some targets, since the modulo instruction is undefined if the
2034 quotient can't be represented in the computation mode. We shorten
2035 only if unsigned or if dividing by something we know != -1. */
2036 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2037 || (TREE_CODE (op1) == INTEGER_CST
2038 && ! integer_all_onesp (op1)));
2043 case TRUTH_ANDIF_EXPR:
2044 case TRUTH_ORIF_EXPR:
2045 case TRUTH_AND_EXPR:
2047 case TRUTH_XOR_EXPR:
2048 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2049 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2050 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2051 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2053 /* Result of these operations is always an int,
2054 but that does not mean the operands should be
2055 converted to ints! */
2056 result_type = integer_type_node;
2057 op0 = truthvalue_conversion (op0);
2058 op1 = truthvalue_conversion (op1);
2063 /* Shift operations: result has same type as first operand;
2064 always convert second operand to int.
2065 Also set SHORT_SHIFT if shifting rightward. */
2068 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2070 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2072 if (tree_int_cst_sgn (op1) < 0)
2073 warning ("right shift count is negative");
2076 if (! integer_zerop (op1))
2079 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2080 warning ("right shift count >= width of type");
2084 /* Use the type of the value to be shifted.
2085 This is what most traditional C compilers do. */
2086 result_type = type0;
2087 /* Unless traditional, convert the shift-count to an integer,
2088 regardless of size of value being shifted. */
2089 if (! flag_traditional)
2091 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2092 op1 = convert (integer_type_node, op1);
2093 /* Avoid converting op1 to result_type later. */
2100 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2102 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2104 if (tree_int_cst_sgn (op1) < 0)
2105 warning ("left shift count is negative");
2107 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2108 warning ("left shift count >= width of type");
2111 /* Use the type of the value to be shifted.
2112 This is what most traditional C compilers do. */
2113 result_type = type0;
2114 /* Unless traditional, convert the shift-count to an integer,
2115 regardless of size of value being shifted. */
2116 if (! flag_traditional)
2118 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2119 op1 = convert (integer_type_node, op1);
2120 /* Avoid converting op1 to result_type later. */
2128 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2130 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2132 if (tree_int_cst_sgn (op1) < 0)
2133 warning ("shift count is negative");
2134 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2135 warning ("shift count >= width of type");
2138 /* Use the type of the value to be shifted.
2139 This is what most traditional C compilers do. */
2140 result_type = type0;
2141 /* Unless traditional, convert the shift-count to an integer,
2142 regardless of size of value being shifted. */
2143 if (! flag_traditional)
2145 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2146 op1 = convert (integer_type_node, op1);
2147 /* Avoid converting op1 to result_type later. */
2155 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2156 warning ("comparing floating point with == or != is unsafe");
2157 /* Result of comparison is always int,
2158 but don't convert the args to int! */
2159 build_type = integer_type_node;
2160 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2161 || code0 == COMPLEX_TYPE)
2162 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2163 || code1 == COMPLEX_TYPE))
2165 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2167 register tree tt0 = TREE_TYPE (type0);
2168 register tree tt1 = TREE_TYPE (type1);
2169 /* Anything compares with void *. void * compares with anything.
2170 Otherwise, the targets must be compatible
2171 and both must be object or both incomplete. */
2172 if (comp_target_types (type0, type1))
2173 result_type = common_type (type0, type1);
2174 else if (VOID_TYPE_P (tt0))
2176 /* op0 != orig_op0 detects the case of something
2177 whose value is 0 but which isn't a valid null ptr const. */
2178 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2179 && TREE_CODE (tt1) == FUNCTION_TYPE)
2180 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2182 else if (VOID_TYPE_P (tt1))
2184 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2185 && TREE_CODE (tt0) == FUNCTION_TYPE)
2186 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2189 pedwarn ("comparison of distinct pointer types lacks a cast");
2191 if (result_type == NULL_TREE)
2192 result_type = ptr_type_node;
2194 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2195 && integer_zerop (op1))
2196 result_type = type0;
2197 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2198 && integer_zerop (op0))
2199 result_type = type1;
2200 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2202 result_type = type0;
2203 if (! flag_traditional)
2204 pedwarn ("comparison between pointer and integer");
2206 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2208 result_type = type1;
2209 if (! flag_traditional)
2210 pedwarn ("comparison between pointer and integer");
2216 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2217 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2219 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2221 if (comp_target_types (type0, type1))
2223 result_type = common_type (type0, type1);
2225 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2226 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2230 result_type = ptr_type_node;
2231 pedwarn ("comparison of distinct pointer types lacks a cast");
2240 build_type = integer_type_node;
2241 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2242 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2244 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2246 if (comp_target_types (type0, type1))
2248 result_type = common_type (type0, type1);
2249 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2250 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2251 pedwarn ("comparison of complete and incomplete pointers");
2253 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2254 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2258 result_type = ptr_type_node;
2259 pedwarn ("comparison of distinct pointer types lacks a cast");
2262 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2263 && integer_zerop (op1))
2265 result_type = type0;
2266 if (pedantic || extra_warnings)
2267 pedwarn ("ordered comparison of pointer with integer zero");
2269 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2270 && integer_zerop (op0))
2272 result_type = type1;
2274 pedwarn ("ordered comparison of pointer with integer zero");
2276 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2278 result_type = type0;
2279 if (! flag_traditional)
2280 pedwarn ("comparison between pointer and integer");
2282 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2284 result_type = type1;
2285 if (! flag_traditional)
2286 pedwarn ("comparison between pointer and integer");
2290 case UNORDERED_EXPR:
2297 build_type = integer_type_node;
2298 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2300 error ("unordered comparison on non-floating point argument");
2301 return error_mark_node;
2310 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2312 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2314 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2316 if (shorten || common || short_compare)
2317 result_type = common_type (type0, type1);
2319 /* For certain operations (which identify themselves by shorten != 0)
2320 if both args were extended from the same smaller type,
2321 do the arithmetic in that type and then extend.
2323 shorten !=0 and !=1 indicates a bitwise operation.
2324 For them, this optimization is safe only if
2325 both args are zero-extended or both are sign-extended.
2326 Otherwise, we might change the result.
2327 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2328 but calculated in (unsigned short) it would be (unsigned short)-1. */
2330 if (shorten && none_complex)
2332 int unsigned0, unsigned1;
2333 tree arg0 = get_narrower (op0, &unsigned0);
2334 tree arg1 = get_narrower (op1, &unsigned1);
2335 /* UNS is 1 if the operation to be done is an unsigned one. */
2336 int uns = TREE_UNSIGNED (result_type);
2339 final_type = result_type;
2341 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2342 but it *requires* conversion to FINAL_TYPE. */
2344 if ((TYPE_PRECISION (TREE_TYPE (op0))
2345 == TYPE_PRECISION (TREE_TYPE (arg0)))
2346 && TREE_TYPE (op0) != final_type)
2347 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2348 if ((TYPE_PRECISION (TREE_TYPE (op1))
2349 == TYPE_PRECISION (TREE_TYPE (arg1)))
2350 && TREE_TYPE (op1) != final_type)
2351 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2353 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2355 /* For bitwise operations, signedness of nominal type
2356 does not matter. Consider only how operands were extended. */
2360 /* Note that in all three cases below we refrain from optimizing
2361 an unsigned operation on sign-extended args.
2362 That would not be valid. */
2364 /* Both args variable: if both extended in same way
2365 from same width, do it in that width.
2366 Do it unsigned if args were zero-extended. */
2367 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2368 < TYPE_PRECISION (result_type))
2369 && (TYPE_PRECISION (TREE_TYPE (arg1))
2370 == TYPE_PRECISION (TREE_TYPE (arg0)))
2371 && unsigned0 == unsigned1
2372 && (unsigned0 || !uns))
2374 = signed_or_unsigned_type (unsigned0,
2375 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2376 else if (TREE_CODE (arg0) == INTEGER_CST
2377 && (unsigned1 || !uns)
2378 && (TYPE_PRECISION (TREE_TYPE (arg1))
2379 < TYPE_PRECISION (result_type))
2380 && (type = signed_or_unsigned_type (unsigned1,
2382 int_fits_type_p (arg0, type)))
2384 else if (TREE_CODE (arg1) == INTEGER_CST
2385 && (unsigned0 || !uns)
2386 && (TYPE_PRECISION (TREE_TYPE (arg0))
2387 < TYPE_PRECISION (result_type))
2388 && (type = signed_or_unsigned_type (unsigned0,
2390 int_fits_type_p (arg1, type)))
2394 /* Shifts can be shortened if shifting right. */
2399 tree arg0 = get_narrower (op0, &unsigned_arg);
2401 final_type = result_type;
2403 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2404 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2406 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2407 /* We can shorten only if the shift count is less than the
2408 number of bits in the smaller type size. */
2409 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2410 /* We cannot drop an unsigned shift after sign-extension. */
2411 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2413 /* Do an unsigned shift if the operand was zero-extended. */
2415 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
2416 /* Convert value-to-be-shifted to that type. */
2417 if (TREE_TYPE (op0) != result_type)
2418 op0 = convert (result_type, op0);
2423 /* Comparison operations are shortened too but differently.
2424 They identify themselves by setting short_compare = 1. */
2428 /* Don't write &op0, etc., because that would prevent op0
2429 from being kept in a register.
2430 Instead, make copies of the our local variables and
2431 pass the copies by reference, then copy them back afterward. */
2432 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2433 enum tree_code xresultcode = resultcode;
2435 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2440 op0 = xop0, op1 = xop1;
2442 resultcode = xresultcode;
2444 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2445 && skip_evaluation == 0)
2447 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2448 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2449 int unsignedp0, unsignedp1;
2450 tree primop0 = get_narrower (op0, &unsignedp0);
2451 tree primop1 = get_narrower (op1, &unsignedp1);
2455 STRIP_TYPE_NOPS (xop0);
2456 STRIP_TYPE_NOPS (xop1);
2458 /* Give warnings for comparisons between signed and unsigned
2459 quantities that may fail.
2461 Do the checking based on the original operand trees, so that
2462 casts will be considered, but default promotions won't be.
2464 Do not warn if the comparison is being done in a signed type,
2465 since the signed type will only be chosen if it can represent
2466 all the values of the unsigned type. */
2467 if (! TREE_UNSIGNED (result_type))
2469 /* Do not warn if both operands are the same signedness. */
2470 else if (op0_signed == op1_signed)
2477 sop = xop0, uop = xop1;
2479 sop = xop1, uop = xop0;
2481 /* Do not warn if the signed quantity is an
2482 unsuffixed integer literal (or some static
2483 constant expression involving such literals or a
2484 conditional expression involving such literals)
2485 and it is non-negative. */
2486 if (tree_expr_nonnegative_p (sop))
2488 /* Do not warn if the comparison is an equality operation,
2489 the unsigned quantity is an integral constant, and it
2490 would fit in the result if the result were signed. */
2491 else if (TREE_CODE (uop) == INTEGER_CST
2492 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2493 && int_fits_type_p (uop, signed_type (result_type)))
2495 /* Do not warn if the unsigned quantity is an enumeration
2496 constant and its maximum value would fit in the result
2497 if the result were signed. */
2498 else if (TREE_CODE (uop) == INTEGER_CST
2499 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2500 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2501 signed_type (result_type)))
2504 warning ("comparison between signed and unsigned");
2507 /* Warn if two unsigned values are being compared in a size
2508 larger than their original size, and one (and only one) is the
2509 result of a `~' operator. This comparison will always fail.
2511 Also warn if one operand is a constant, and the constant
2512 does not have all bits set that are set in the ~ operand
2513 when it is extended. */
2515 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2516 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2518 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2519 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2522 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2525 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2528 HOST_WIDE_INT constant, mask;
2529 int unsignedp, bits;
2531 if (host_integerp (primop0, 0))
2534 unsignedp = unsignedp1;
2535 constant = tree_low_cst (primop0, 0);
2540 unsignedp = unsignedp0;
2541 constant = tree_low_cst (primop1, 0);
2544 bits = TYPE_PRECISION (TREE_TYPE (primop));
2545 if (bits < TYPE_PRECISION (result_type)
2546 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2548 mask = (~ (HOST_WIDE_INT) 0) << bits;
2549 if ((mask & constant) != mask)
2550 warning ("comparison of promoted ~unsigned with constant");
2553 else if (unsignedp0 && unsignedp1
2554 && (TYPE_PRECISION (TREE_TYPE (primop0))
2555 < TYPE_PRECISION (result_type))
2556 && (TYPE_PRECISION (TREE_TYPE (primop1))
2557 < TYPE_PRECISION (result_type)))
2558 warning ("comparison of promoted ~unsigned with unsigned");
2564 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2565 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2566 Then the expression will be built.
2567 It will be given type FINAL_TYPE if that is nonzero;
2568 otherwise, it will be given type RESULT_TYPE. */
2572 binary_op_error (code);
2573 return error_mark_node;
2578 if (TREE_TYPE (op0) != result_type)
2579 op0 = convert (result_type, op0);
2580 if (TREE_TYPE (op1) != result_type)
2581 op1 = convert (result_type, op1);
2584 if (build_type == NULL_TREE)
2585 build_type = result_type;
2588 register tree result = build (resultcode, build_type, op0, op1);
2589 register tree folded;
2591 folded = fold (result);
2592 if (folded == result)
2593 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2594 if (final_type != 0)
2595 return convert (final_type, folded);
2600 /* Return a tree for the sum or difference (RESULTCODE says which)
2601 of pointer PTROP and integer INTOP. */
2604 pointer_int_sum (resultcode, ptrop, intop)
2605 enum tree_code resultcode;
2606 register tree ptrop, intop;
2610 register tree result;
2611 register tree folded;
2613 /* The result is a pointer of the same type that is being added. */
2615 register tree result_type = TREE_TYPE (ptrop);
2617 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2619 if (pedantic || warn_pointer_arith)
2620 pedwarn ("pointer of type `void *' used in arithmetic");
2621 size_exp = integer_one_node;
2623 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2625 if (pedantic || warn_pointer_arith)
2626 pedwarn ("pointer to a function used in arithmetic");
2627 size_exp = integer_one_node;
2630 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2632 /* If what we are about to multiply by the size of the elements
2633 contains a constant term, apply distributive law
2634 and multiply that constant term separately.
2635 This helps produce common subexpressions. */
2637 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2638 && ! TREE_CONSTANT (intop)
2639 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2640 && TREE_CONSTANT (size_exp)
2641 /* If the constant comes from pointer subtraction,
2642 skip this optimization--it would cause an error. */
2643 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2644 /* If the constant is unsigned, and smaller than the pointer size,
2645 then we must skip this optimization. This is because it could cause
2646 an overflow error if the constant is negative but INTOP is not. */
2647 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2648 || (TYPE_PRECISION (TREE_TYPE (intop))
2649 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2651 enum tree_code subcode = resultcode;
2652 tree int_type = TREE_TYPE (intop);
2653 if (TREE_CODE (intop) == MINUS_EXPR)
2654 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2655 /* Convert both subexpression types to the type of intop,
2656 because weird cases involving pointer arithmetic
2657 can result in a sum or difference with different type args. */
2658 ptrop = build_binary_op (subcode, ptrop,
2659 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2660 intop = convert (int_type, TREE_OPERAND (intop, 0));
2663 /* Convert the integer argument to a type the same size as sizetype
2664 so the multiply won't overflow spuriously. */
2666 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2667 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2668 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2669 TREE_UNSIGNED (sizetype)), intop);
2671 /* Replace the integer argument with a suitable product by the object size.
2672 Do this multiplication as signed, then convert to the appropriate
2673 pointer type (actually unsigned integral). */
2675 intop = convert (result_type,
2676 build_binary_op (MULT_EXPR, intop,
2677 convert (TREE_TYPE (intop), size_exp), 1));
2679 /* Create the sum or difference. */
2681 result = build (resultcode, result_type, ptrop, intop);
2683 folded = fold (result);
2684 if (folded == result)
2685 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2689 /* Return a tree for the difference of pointers OP0 and OP1.
2690 The resulting tree has type int. */
2693 pointer_diff (op0, op1)
2694 register tree op0, op1;
2696 register tree result, folded;
2697 tree restype = ptrdiff_type_node;
2699 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2700 tree con0, con1, lit0, lit1;
2701 tree orig_op1 = op1;
2703 if (pedantic || warn_pointer_arith)
2705 if (TREE_CODE (target_type) == VOID_TYPE)
2706 pedwarn ("pointer of type `void *' used in subtraction");
2707 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2708 pedwarn ("pointer to a function used in subtraction");
2711 /* If the conversion to ptrdiff_type does anything like widening or
2712 converting a partial to an integral mode, we get a convert_expression
2713 that is in the way to do any simplifications.
2714 (fold-const.c doesn't know that the extra bits won't be needed.
2715 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2716 different mode in place.)
2717 So first try to find a common term here 'by hand'; we want to cover
2718 at least the cases that occur in legal static initializers. */
2719 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2720 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2722 if (TREE_CODE (con0) == PLUS_EXPR)
2724 lit0 = TREE_OPERAND (con0, 1);
2725 con0 = TREE_OPERAND (con0, 0);
2728 lit0 = integer_zero_node;
2730 if (TREE_CODE (con1) == PLUS_EXPR)
2732 lit1 = TREE_OPERAND (con1, 1);
2733 con1 = TREE_OPERAND (con1, 0);
2736 lit1 = integer_zero_node;
2738 if (operand_equal_p (con0, con1, 0))
2745 /* First do the subtraction as integers;
2746 then drop through to build the divide operator.
2747 Do not do default conversions on the minus operator
2748 in case restype is a short type. */
2750 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2751 convert (restype, op1), 0);
2752 /* This generates an error if op1 is pointer to incomplete type. */
2753 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2754 error ("arithmetic on pointer to an incomplete type");
2756 /* This generates an error if op0 is pointer to incomplete type. */
2757 op1 = c_size_in_bytes (target_type);
2759 /* Divide by the size, in easiest possible way. */
2761 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2763 folded = fold (result);
2764 if (folded == result)
2765 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2769 /* Construct and perhaps optimize a tree representation
2770 for a unary operation. CODE, a tree_code, specifies the operation
2771 and XARG is the operand. NOCONVERT nonzero suppresses
2772 the default promotions (such as from short to int). */
2775 build_unary_op (code, xarg, noconvert)
2776 enum tree_code code;
2780 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2781 register tree arg = xarg;
2782 register tree argtype = 0;
2783 register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2786 if (typecode == ERROR_MARK)
2787 return error_mark_node;
2788 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2789 typecode = INTEGER_TYPE;
2794 /* This is used for unary plus, because a CONVERT_EXPR
2795 is enough to prevent anybody from looking inside for
2796 associativity, but won't generate any code. */
2797 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2798 || typecode == COMPLEX_TYPE))
2800 error ("wrong type argument to unary plus");
2801 return error_mark_node;
2803 else if (!noconvert)
2804 arg = default_conversion (arg);
2808 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2809 || typecode == COMPLEX_TYPE))
2811 error ("wrong type argument to unary minus");
2812 return error_mark_node;
2814 else if (!noconvert)
2815 arg = default_conversion (arg);
2819 if (typecode == COMPLEX_TYPE)
2823 pedwarn ("ISO C does not support `~' for complex conjugation");
2825 arg = default_conversion (arg);
2827 else if (typecode != INTEGER_TYPE)
2829 error ("wrong type argument to bit-complement");
2830 return error_mark_node;
2832 else if (!noconvert)
2833 arg = default_conversion (arg);
2837 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2838 || typecode == COMPLEX_TYPE))
2840 error ("wrong type argument to abs");
2841 return error_mark_node;
2843 else if (!noconvert)
2844 arg = default_conversion (arg);
2848 /* Conjugating a real value is a no-op, but allow it anyway. */
2849 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2850 || typecode == COMPLEX_TYPE))
2852 error ("wrong type argument to conjugation");
2853 return error_mark_node;
2855 else if (!noconvert)
2856 arg = default_conversion (arg);
2859 case TRUTH_NOT_EXPR:
2860 if (typecode != INTEGER_TYPE
2861 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2862 && typecode != COMPLEX_TYPE
2863 /* These will convert to a pointer. */
2864 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2866 error ("wrong type argument to unary exclamation mark");
2867 return error_mark_node;
2869 arg = truthvalue_conversion (arg);
2870 return invert_truthvalue (arg);
2876 if (TREE_CODE (arg) == COMPLEX_CST)
2877 return TREE_REALPART (arg);
2878 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2879 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2884 if (TREE_CODE (arg) == COMPLEX_CST)
2885 return TREE_IMAGPART (arg);
2886 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2887 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2889 return convert (TREE_TYPE (arg), integer_zero_node);
2891 case PREINCREMENT_EXPR:
2892 case POSTINCREMENT_EXPR:
2893 case PREDECREMENT_EXPR:
2894 case POSTDECREMENT_EXPR:
2895 /* Handle complex lvalues (when permitted)
2896 by reduction to simpler cases. */
2898 val = unary_complex_lvalue (code, arg);
2902 /* Increment or decrement the real part of the value,
2903 and don't change the imaginary part. */
2904 if (typecode == COMPLEX_TYPE)
2909 pedwarn ("ISO C does not support `++' and `--' on complex types");
2911 arg = stabilize_reference (arg);
2912 real = build_unary_op (REALPART_EXPR, arg, 1);
2913 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2914 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2915 build_unary_op (code, real, 1), imag);
2918 /* Report invalid types. */
2920 if (typecode != POINTER_TYPE
2921 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2923 error ("wrong type argument to %s",
2924 code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2925 ? "increment" : "decrement");
2926 return error_mark_node;
2931 tree result_type = TREE_TYPE (arg);
2933 arg = get_unwidened (arg, 0);
2934 argtype = TREE_TYPE (arg);
2936 /* Compute the increment. */
2938 if (typecode == POINTER_TYPE)
2940 /* If pointer target is an undefined struct,
2941 we just cannot know how to do the arithmetic. */
2942 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2943 error ("%s of pointer to unknown structure",
2944 code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2945 ? "increment" : "decrement");
2946 else if ((pedantic || warn_pointer_arith)
2947 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2948 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2949 pedwarn ("wrong type argument to %s",
2950 code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2951 ? "increment" : "decrement");
2952 inc = c_size_in_bytes (TREE_TYPE (result_type));
2955 inc = integer_one_node;
2957 inc = convert (argtype, inc);
2959 /* Handle incrementing a cast-expression. */
2962 switch (TREE_CODE (arg))
2967 case FIX_TRUNC_EXPR:
2968 case FIX_FLOOR_EXPR:
2969 case FIX_ROUND_EXPR:
2971 pedantic_lvalue_warning (CONVERT_EXPR);
2972 /* If the real type has the same machine representation
2973 as the type it is cast to, we can make better output
2974 by adding directly to the inside of the cast. */
2975 if ((TREE_CODE (TREE_TYPE (arg))
2976 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2977 && (TYPE_MODE (TREE_TYPE (arg))
2978 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2979 arg = TREE_OPERAND (arg, 0);
2982 tree incremented, modify, value;
2983 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2984 value = boolean_increment (code, arg);
2987 arg = stabilize_reference (arg);
2988 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2991 value = save_expr (arg);
2992 incremented = build (((code == PREINCREMENT_EXPR
2993 || code == POSTINCREMENT_EXPR)
2994 ? PLUS_EXPR : MINUS_EXPR),
2995 argtype, value, inc);
2996 TREE_SIDE_EFFECTS (incremented) = 1;
2997 modify = build_modify_expr (arg, NOP_EXPR, incremented);
2998 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3000 TREE_USED (value) = 1;
3010 /* Complain about anything else that is not a true lvalue. */
3011 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3012 || code == POSTINCREMENT_EXPR)
3013 ? "invalid lvalue in increment"
3014 : "invalid lvalue in decrement")))
3015 return error_mark_node;
3017 /* Report a read-only lvalue. */
3018 if (TREE_READONLY (arg))
3019 readonly_warning (arg,
3020 ((code == PREINCREMENT_EXPR
3021 || code == POSTINCREMENT_EXPR)
3022 ? "increment" : "decrement"));
3024 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3025 val = boolean_increment (code, arg);
3027 val = build (code, TREE_TYPE (arg), arg, inc);
3028 TREE_SIDE_EFFECTS (val) = 1;
3029 val = convert (result_type, val);
3030 if (TREE_CODE (val) != code)
3031 TREE_NO_UNUSED_WARNING (val) = 1;
3036 /* Note that this operation never does default_conversion
3037 regardless of NOCONVERT. */
3039 /* Let &* cancel out to simplify resulting code. */
3040 if (TREE_CODE (arg) == INDIRECT_REF)
3042 /* Don't let this be an lvalue. */
3043 if (lvalue_p (TREE_OPERAND (arg, 0)))
3044 return non_lvalue (TREE_OPERAND (arg, 0));
3045 return TREE_OPERAND (arg, 0);
3048 /* For &x[y], return x+y */
3049 if (TREE_CODE (arg) == ARRAY_REF)
3051 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3052 return error_mark_node;
3053 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3054 TREE_OPERAND (arg, 1), 1);
3057 /* Handle complex lvalues (when permitted)
3058 by reduction to simpler cases. */
3059 val = unary_complex_lvalue (code, arg);
3063 #if 0 /* Turned off because inconsistent;
3064 float f; *&(int)f = 3.4 stores in int format
3065 whereas (int)f = 3.4 stores in float format. */
3066 /* Address of a cast is just a cast of the address
3067 of the operand of the cast. */
3068 switch (TREE_CODE (arg))
3073 case FIX_TRUNC_EXPR:
3074 case FIX_FLOOR_EXPR:
3075 case FIX_ROUND_EXPR:
3078 pedwarn ("ISO C forbids the address of a cast expression");
3079 return convert (build_pointer_type (TREE_TYPE (arg)),
3080 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3085 /* Allow the address of a constructor if all the elements
3087 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3089 /* Anything not already handled and not a true memory reference
3091 else if (typecode != FUNCTION_TYPE
3092 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3093 return error_mark_node;
3095 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3096 argtype = TREE_TYPE (arg);
3098 /* If the lvalue is const or volatile, merge that into the type
3099 to which the address will point. Note that you can't get a
3100 restricted pointer by taking the address of something, so we
3101 only have to deal with `const' and `volatile' here. */
3102 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3103 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3104 argtype = c_build_type_variant (argtype,
3105 TREE_READONLY (arg),
3106 TREE_THIS_VOLATILE (arg));
3108 argtype = build_pointer_type (argtype);
3110 if (mark_addressable (arg) == 0)
3111 return error_mark_node;
3116 if (TREE_CODE (arg) == COMPONENT_REF)
3118 tree field = TREE_OPERAND (arg, 1);
3120 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3122 if (DECL_C_BIT_FIELD (field))
3124 error ("attempt to take address of bit-field structure member `%s'",
3125 IDENTIFIER_POINTER (DECL_NAME (field)));
3126 return error_mark_node;
3129 addr = fold (build (PLUS_EXPR, argtype,
3130 convert (argtype, addr),
3131 convert (argtype, byte_position (field))));
3134 addr = build1 (code, argtype, arg);
3136 /* Address of a static or external variable or
3137 file-scope function counts as a constant. */
3139 && ! (TREE_CODE (arg) == FUNCTION_DECL
3140 && DECL_CONTEXT (arg) != 0))
3141 TREE_CONSTANT (addr) = 1;
3150 argtype = TREE_TYPE (arg);
3151 return fold (build1 (code, argtype, arg));
3155 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3156 convert ARG with the same conversions in the same order
3157 and return the result. */
3160 convert_sequence (conversions, arg)
3164 switch (TREE_CODE (conversions))
3169 case FIX_TRUNC_EXPR:
3170 case FIX_FLOOR_EXPR:
3171 case FIX_ROUND_EXPR:
3173 return convert (TREE_TYPE (conversions),
3174 convert_sequence (TREE_OPERAND (conversions, 0),
3183 /* Return nonzero if REF is an lvalue valid for this language.
3184 Lvalues can be assigned, unless their type has TYPE_READONLY.
3185 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3191 register enum tree_code code = TREE_CODE (ref);
3198 return lvalue_p (TREE_OPERAND (ref, 0));
3209 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3210 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3214 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3221 /* Return nonzero if REF is an lvalue valid for this language;
3222 otherwise, print an error message and return zero. */
3225 lvalue_or_else (ref, msgid)
3229 int win = lvalue_p (ref);
3232 error ("%s", msgid);
3237 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3238 for certain kinds of expressions which are not really lvalues
3239 but which we can accept as lvalues.
3241 If ARG is not a kind of expression we can handle, return zero. */
3244 unary_complex_lvalue (code, arg)
3245 enum tree_code code;
3248 /* Handle (a, b) used as an "lvalue". */
3249 if (TREE_CODE (arg) == COMPOUND_EXPR)
3251 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3253 /* If this returns a function type, it isn't really being used as
3254 an lvalue, so don't issue a warning about it. */
3255 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3256 pedantic_lvalue_warning (COMPOUND_EXPR);
3258 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3259 TREE_OPERAND (arg, 0), real_result);
3262 /* Handle (a ? b : c) used as an "lvalue". */
3263 if (TREE_CODE (arg) == COND_EXPR)
3265 pedantic_lvalue_warning (COND_EXPR);
3266 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3267 pedantic_lvalue_warning (COMPOUND_EXPR);
3269 return (build_conditional_expr
3270 (TREE_OPERAND (arg, 0),
3271 build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3272 build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3278 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3279 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3282 pedantic_lvalue_warning (code)
3283 enum tree_code code;
3289 pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3292 pedwarn ("ISO C forbids use of compound expressions as lvalues");
3295 pedwarn ("ISO C forbids use of cast expressions as lvalues");
3300 /* Warn about storing in something that is `const'. */
3303 readonly_warning (arg, msgid)
3307 if (TREE_CODE (arg) == COMPONENT_REF)
3309 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3310 readonly_warning (TREE_OPERAND (arg, 0), msgid);
3312 pedwarn ("%s of read-only member `%s'", _(msgid),
3313 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3315 else if (TREE_CODE (arg) == VAR_DECL)
3316 pedwarn ("%s of read-only variable `%s'", _(msgid),
3317 IDENTIFIER_POINTER (DECL_NAME (arg)));
3319 pedwarn ("%s of read-only location", _(msgid));
3322 /* Mark EXP saying that we need to be able to take the
3323 address of it; it should not be allocated in a register.
3324 Value is 1 if successful. */
3327 mark_addressable (exp)
3330 register tree x = exp;
3332 switch (TREE_CODE (x))
3335 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3337 error ("cannot take address of bitfield `%s'",
3338 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3342 /* ... fall through ... */
3348 x = TREE_OPERAND (x, 0);
3352 TREE_ADDRESSABLE (x) = 1;
3359 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3360 && DECL_NONLOCAL (x))
3362 if (TREE_PUBLIC (x))
3364 error ("global register variable `%s' used in nested function",
3365 IDENTIFIER_POINTER (DECL_NAME (x)));
3368 pedwarn ("register variable `%s' used in nested function",
3369 IDENTIFIER_POINTER (DECL_NAME (x)));
3371 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3373 if (TREE_PUBLIC (x))
3375 error ("address of global register variable `%s' requested",
3376 IDENTIFIER_POINTER (DECL_NAME (x)));
3380 /* If we are making this addressable due to its having
3381 volatile components, give a different error message. Also
3382 handle the case of an unnamed parameter by not trying
3383 to give the name. */
3385 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3387 error ("cannot put object with volatile field into register");
3391 pedwarn ("address of register variable `%s' requested",
3392 IDENTIFIER_POINTER (DECL_NAME (x)));
3394 put_var_into_stack (x);
3398 TREE_ADDRESSABLE (x) = 1;
3399 #if 0 /* poplevel deals with this now. */
3400 if (DECL_CONTEXT (x) == 0)
3401 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3409 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3412 build_conditional_expr (ifexp, op1, op2)
3413 tree ifexp, op1, op2;
3415 register tree type1;
3416 register tree type2;
3417 register enum tree_code code1;
3418 register enum tree_code code2;
3419 register tree result_type = NULL;
3420 tree orig_op1 = op1, orig_op2 = op2;
3422 ifexp = truthvalue_conversion (default_conversion (ifexp));
3424 #if 0 /* Produces wrong result if within sizeof. */
3425 /* Don't promote the operands separately if they promote
3426 the same way. Return the unpromoted type and let the combined
3427 value get promoted if necessary. */
3429 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3430 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3431 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3432 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3434 if (TREE_CODE (ifexp) == INTEGER_CST)
3435 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3437 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3441 /* Promote both alternatives. */
3443 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3444 op1 = default_conversion (op1);
3445 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3446 op2 = default_conversion (op2);
3448 if (TREE_CODE (ifexp) == ERROR_MARK
3449 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3450 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3451 return error_mark_node;
3453 type1 = TREE_TYPE (op1);
3454 code1 = TREE_CODE (type1);
3455 type2 = TREE_TYPE (op2);
3456 code2 = TREE_CODE (type2);
3458 /* Quickly detect the usual case where op1 and op2 have the same type
3460 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3463 result_type = type1;
3465 result_type = TYPE_MAIN_VARIANT (type1);
3467 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3468 || code1 == COMPLEX_TYPE)
3469 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3470 || code2 == COMPLEX_TYPE))
3472 result_type = common_type (type1, type2);
3474 /* If -Wsign-compare, warn here if type1 and type2 have
3475 different signedness. We'll promote the signed to unsigned
3476 and later code won't know it used to be different.
3477 Do this check on the original types, so that explicit casts
3478 will be considered, but default promotions won't. */
3479 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3480 && !skip_evaluation)
3482 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3483 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3485 if (unsigned_op1 ^ unsigned_op2)
3487 /* Do not warn if the result type is signed, since the
3488 signed type will only be chosen if it can represent
3489 all the values of the unsigned type. */
3490 if (! TREE_UNSIGNED (result_type))
3492 /* Do not warn if the signed quantity is an unsuffixed
3493 integer literal (or some static constant expression
3494 involving such literals) and it is non-negative. */
3495 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3496 || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3499 warning ("signed and unsigned type in conditional expression");
3503 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3505 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3506 pedwarn ("ISO C forbids conditional expr with only one void side");
3507 result_type = void_type_node;
3509 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3511 if (comp_target_types (type1, type2))
3512 result_type = common_type (type1, type2);
3513 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3514 && TREE_CODE (orig_op1) != NOP_EXPR)
3515 result_type = qualify_type (type2, type1);
3516 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3517 && TREE_CODE (orig_op2) != NOP_EXPR)
3518 result_type = qualify_type (type1, type2);
3519 else if (VOID_TYPE_P (TREE_TYPE (type1)))
3521 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3522 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3523 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3524 TREE_TYPE (type2)));
3526 else if (VOID_TYPE_P (TREE_TYPE (type2)))
3528 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3529 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3530 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3531 TREE_TYPE (type1)));
3535 pedwarn ("pointer type mismatch in conditional expression");
3536 result_type = build_pointer_type (void_type_node);
3539 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3541 if (! integer_zerop (op2))
3542 pedwarn ("pointer/integer type mismatch in conditional expression");
3545 op2 = null_pointer_node;
3547 result_type = type1;
3549 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3551 if (!integer_zerop (op1))
3552 pedwarn ("pointer/integer type mismatch in conditional expression");
3555 op1 = null_pointer_node;
3557 result_type = type2;
3562 if (flag_cond_mismatch)
3563 result_type = void_type_node;
3566 error ("type mismatch in conditional expression");
3567 return error_mark_node;
3571 /* Merge const and volatile flags of the incoming types. */
3573 = build_type_variant (result_type,
3574 TREE_READONLY (op1) || TREE_READONLY (op2),
3575 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3577 if (result_type != TREE_TYPE (op1))
3578 op1 = convert_and_check (result_type, op1);
3579 if (result_type != TREE_TYPE (op2))
3580 op2 = convert_and_check (result_type, op2);
3582 if (TREE_CODE (ifexp) == INTEGER_CST)
3583 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3585 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3588 /* Given a list of expressions, return a compound expression
3589 that performs them all and returns the value of the last of them. */
3592 build_compound_expr (list)
3595 return internal_build_compound_expr (list, TRUE);
3599 internal_build_compound_expr (list, first_p)
3605 if (TREE_CHAIN (list) == 0)
3607 /* Convert arrays to pointers when there really is a comma operator. */
3608 if (!first_p && TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
3609 TREE_VALUE (list) = default_conversion (TREE_VALUE (list));
3611 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3612 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3614 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3615 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3616 list = TREE_OPERAND (list, 0);
3619 /* Don't let (0, 0) be null pointer constant. */
3620 if (!first_p && integer_zerop (TREE_VALUE (list)))
3621 return non_lvalue (TREE_VALUE (list));
3622 return TREE_VALUE (list);
3625 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3627 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3629 /* The left-hand operand of a comma expression is like an expression
3630 statement: with -W or -Wunused, we should warn if it doesn't have
3631 any side-effects, unless it was explicitly cast to (void). */
3632 if ((extra_warnings || warn_unused_value)
3633 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3634 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3635 warning ("left-hand operand of comma expression has no effect");
3637 /* When pedantic, a compound expression can be neither an lvalue
3638 nor an integer constant expression. */
3643 /* With -Wunused, we should also warn if the left-hand operand does have
3644 side-effects, but computes a value which is not used. For example, in
3645 `foo() + bar(), baz()' the result of the `+' operator is not used,
3646 so we should issue a warning. */
3647 else if (warn_unused_value)
3648 warn_if_unused_value (TREE_VALUE (list));
3650 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3653 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3656 build_c_cast (type, expr)
3660 register tree value = expr;
3662 if (type == error_mark_node || expr == error_mark_node)
3663 return error_mark_node;
3664 type = TYPE_MAIN_VARIANT (type);
3667 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3668 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3669 value = TREE_OPERAND (value, 0);
3672 if (TREE_CODE (type) == ARRAY_TYPE)
3674 error ("cast specifies array type");
3675 return error_mark_node;
3678 if (TREE_CODE (type) == FUNCTION_TYPE)
3680 error ("cast specifies function type");
3681 return error_mark_node;
3684 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3688 if (TREE_CODE (type) == RECORD_TYPE
3689 || TREE_CODE (type) == UNION_TYPE)
3690 pedwarn ("ISO C forbids casting nonscalar to the same type");
3693 else if (TREE_CODE (type) == UNION_TYPE)
3696 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3697 || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3698 value = default_conversion (value);
3700 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3701 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3702 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3711 pedwarn ("ISO C forbids casts to union type");
3712 if (TYPE_NAME (type) != 0)
3714 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3715 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3717 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3721 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3722 build_tree_list (field, value)),
3724 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3727 error ("cast to union type from type not present in union");
3728 return error_mark_node;
3734 /* If casting to void, avoid the error that would come
3735 from default_conversion in the case of a non-lvalue array. */
3736 if (type == void_type_node)
3737 return build1 (CONVERT_EXPR, type, value);
3739 /* Convert functions and arrays to pointers,
3740 but don't convert any other types. */
3741 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3742 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3743 value = default_conversion (value);
3744 otype = TREE_TYPE (value);
3746 /* Optionally warn about potentially worrisome casts. */
3749 && TREE_CODE (type) == POINTER_TYPE
3750 && TREE_CODE (otype) == POINTER_TYPE)
3752 tree in_type = type;
3753 tree in_otype = otype;
3756 /* Check that the qualifiers on IN_TYPE are a superset of
3757 the qualifiers of IN_OTYPE. The outermost level of
3758 POINTER_TYPE nodes is uninteresting and we stop as soon
3759 as we hit a non-POINTER_TYPE node on either type. */
3762 in_otype = TREE_TYPE (in_otype);
3763 in_type = TREE_TYPE (in_type);
3764 warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3766 while (TREE_CODE (in_type) == POINTER_TYPE
3767 && TREE_CODE (in_otype) == POINTER_TYPE);
3770 /* There are qualifiers present in IN_OTYPE that are not
3771 present in IN_TYPE. */
3772 warning ("cast discards qualifiers from pointer target type");
3775 /* Warn about possible alignment problems. */
3776 if (STRICT_ALIGNMENT && warn_cast_align
3777 && TREE_CODE (type) == POINTER_TYPE
3778 && TREE_CODE (otype) == POINTER_TYPE
3779 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3780 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3781 /* Don't warn about opaque types, where the actual alignment
3782 restriction is unknown. */
3783 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3784 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3785 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3786 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3787 warning ("cast increases required alignment of target type");
3789 if (TREE_CODE (type) == INTEGER_TYPE
3790 && TREE_CODE (otype) == POINTER_TYPE
3791 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3792 && !TREE_CONSTANT (value))
3793 warning ("cast from pointer to integer of different size");
3795 if (warn_bad_function_cast
3796 && TREE_CODE (value) == CALL_EXPR
3797 && TREE_CODE (type) != TREE_CODE (otype))
3798 warning ("cast does not match function type");
3800 if (TREE_CODE (type) == POINTER_TYPE
3801 && TREE_CODE (otype) == INTEGER_TYPE
3802 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3803 /* Don't warn about converting any constant. */
3804 && !TREE_CONSTANT (value))
3805 warning ("cast to pointer from integer of different size");
3808 value = convert (type, value);
3810 /* Ignore any integer overflow caused by the cast. */
3811 if (TREE_CODE (value) == INTEGER_CST)
3813 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3814 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3818 /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant. */
3819 if (pedantic && TREE_CODE (value) == INTEGER_CST
3820 && TREE_CODE (expr) == INTEGER_CST
3821 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3822 value = non_lvalue (value);
3824 /* If pedantic, don't let a cast be an lvalue. */
3825 if (value == expr && pedantic)
3826 value = non_lvalue (value);
3831 /* Interpret a cast of expression EXPR to type TYPE. */
3833 c_cast_expr (type, expr)
3836 int saved_wsp = warn_strict_prototypes;
3838 /* This avoids warnings about unprototyped casts on
3839 integers. E.g. "#define SIG_DFL (void(*)())0". */
3840 if (TREE_CODE (expr) == INTEGER_CST)
3841 warn_strict_prototypes = 0;
3842 type = groktypename (type);
3843 warn_strict_prototypes = saved_wsp;
3845 return build_c_cast (type, expr);
3849 /* Build an assignment expression of lvalue LHS from value RHS.
3850 MODIFYCODE is the code for a binary operator that we use
3851 to combine the old value of LHS with RHS to get the new value.
3852 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3855 build_modify_expr (lhs, modifycode, rhs)
3857 enum tree_code modifycode;
3859 register tree result;
3861 tree lhstype = TREE_TYPE (lhs);
3862 tree olhstype = lhstype;
3864 /* Types that aren't fully specified cannot be used in assignments. */
3865 lhs = require_complete_type (lhs);
3867 /* Avoid duplicate error messages from operands that had errors. */
3868 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3869 return error_mark_node;
3871 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3872 /* Do not use STRIP_NOPS here. We do not want an enumerator
3873 whose value is 0 to count as a null pointer constant. */
3874 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3875 rhs = TREE_OPERAND (rhs, 0);
3879 /* Handle control structure constructs used as "lvalues". */
3881 switch (TREE_CODE (lhs))
3883 /* Handle (a, b) used as an "lvalue". */
3885 pedantic_lvalue_warning (COMPOUND_EXPR);
3886 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3887 if (TREE_CODE (newrhs) == ERROR_MARK)
3888 return error_mark_node;
3889 return build (COMPOUND_EXPR, lhstype,
3890 TREE_OPERAND (lhs, 0), newrhs);
3892 /* Handle (a ? b : c) used as an "lvalue". */
3894 pedantic_lvalue_warning (COND_EXPR);
3895 rhs = save_expr (rhs);
3897 /* Produce (a ? (b = rhs) : (c = rhs))
3898 except that the RHS goes through a save-expr
3899 so the code to compute it is only emitted once. */
3901 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3902 build_modify_expr (TREE_OPERAND (lhs, 1),
3904 build_modify_expr (TREE_OPERAND (lhs, 2),
3906 if (TREE_CODE (cond) == ERROR_MARK)
3908 /* Make sure the code to compute the rhs comes out
3909 before the split. */
3910 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3911 /* But cast it to void to avoid an "unused" error. */
3912 convert (void_type_node, rhs), cond);
3918 /* If a binary op has been requested, combine the old LHS value with the RHS
3919 producing the value we should actually store into the LHS. */
3921 if (modifycode != NOP_EXPR)
3923 lhs = stabilize_reference (lhs);
3924 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3927 /* Handle a cast used as an "lvalue".
3928 We have already performed any binary operator using the value as cast.
3929 Now convert the result to the cast type of the lhs,
3930 and then true type of the lhs and store it there;
3931 then convert result back to the cast type to be the value
3932 of the assignment. */
3934 switch (TREE_CODE (lhs))
3939 case FIX_TRUNC_EXPR:
3940 case FIX_FLOOR_EXPR:
3941 case FIX_ROUND_EXPR:
3943 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3944 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3945 newrhs = default_conversion (newrhs);
3947 tree inner_lhs = TREE_OPERAND (lhs, 0);
3949 result = build_modify_expr (inner_lhs, NOP_EXPR,
3950 convert (TREE_TYPE (inner_lhs),
3951 convert (lhstype, newrhs)));
3952 if (TREE_CODE (result) == ERROR_MARK)
3954 pedantic_lvalue_warning (CONVERT_EXPR);
3955 return convert (TREE_TYPE (lhs), result);
3962 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3963 Reject anything strange now. */
3965 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3966 return error_mark_node;
3968 /* Warn about storing in something that is `const'. */
3970 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3971 || ((TREE_CODE (lhstype) == RECORD_TYPE
3972 || TREE_CODE (lhstype) == UNION_TYPE)
3973 && C_TYPE_FIELDS_READONLY (lhstype)))
3974 readonly_warning (lhs, "assignment");
3976 /* If storing into a structure or union member,
3977 it has probably been given type `int'.
3978 Compute the type that would go with
3979 the actual amount of storage the member occupies. */
3981 if (TREE_CODE (lhs) == COMPONENT_REF
3982 && (TREE_CODE (lhstype) == INTEGER_TYPE
3983 || TREE_CODE (lhstype) == BOOLEAN_TYPE
3984 || TREE_CODE (lhstype) == REAL_TYPE
3985 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3986 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3988 /* If storing in a field that is in actuality a short or narrower than one,
3989 we must store in the field in its actual type. */
3991 if (lhstype != TREE_TYPE (lhs))
3993 lhs = copy_node (lhs);
3994 TREE_TYPE (lhs) = lhstype;
3997 /* Convert new value to destination type. */
3999 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4000 NULL_TREE, NULL_TREE, 0);
4001 if (TREE_CODE (newrhs) == ERROR_MARK)
4002 return error_mark_node;
4006 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4007 TREE_SIDE_EFFECTS (result) = 1;
4009 /* If we got the LHS in a different type for storing in,
4010 convert the result back to the nominal type of LHS
4011 so that the value we return always has the same type
4012 as the LHS argument. */
4014 if (olhstype == TREE_TYPE (result))
4016 return convert_for_assignment (olhstype, result, _("assignment"),
4017 NULL_TREE, NULL_TREE, 0);
4020 /* Convert value RHS to type TYPE as preparation for an assignment
4021 to an lvalue of type TYPE.
4022 The real work of conversion is done by `convert'.
4023 The purpose of this function is to generate error messages
4024 for assignments that are not allowed in C.
4025 ERRTYPE is a string to use in error messages:
4026 "assignment", "return", etc. If it is null, this is parameter passing
4027 for a function call (and different error messages are output).
4029 FUNNAME is the name of the function being called,
4030 as an IDENTIFIER_NODE, or null.
4031 PARMNUM is the number of the argument, for printing in error messages. */
4034 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4036 const char *errtype;
4037 tree fundecl, funname;
4040 register enum tree_code codel = TREE_CODE (type);
4041 register tree rhstype;
4042 register enum tree_code coder;
4044 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4045 /* Do not use STRIP_NOPS here. We do not want an enumerator
4046 whose value is 0 to count as a null pointer constant. */
4047 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4048 rhs = TREE_OPERAND (rhs, 0);
4050 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4051 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4052 rhs = default_conversion (rhs);
4053 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4054 rhs = decl_constant_value_for_broken_optimization (rhs);
4056 rhstype = TREE_TYPE (rhs);
4057 coder = TREE_CODE (rhstype);
4059 if (coder == ERROR_MARK)
4060 return error_mark_node;
4062 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4064 overflow_warning (rhs);
4065 /* Check for Objective-C protocols. This will issue a warning if
4066 there are protocol violations. No need to use the return value. */
4067 maybe_objc_comptypes (type, rhstype, 0);
4071 if (coder == VOID_TYPE)
4073 error ("void value not ignored as it ought to be");
4074 return error_mark_node;
4076 /* A type converts to a reference to it.
4077 This code doesn't fully support references, it's just for the
4078 special case of va_start and va_copy. */
4079 if (codel == REFERENCE_TYPE
4080 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4082 if (mark_addressable (rhs) == 0)
4083 return error_mark_node;
4084 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4086 /* We already know that these two types are compatible, but they
4087 may not be exactly identical. In fact, `TREE_TYPE (type)' is
4088 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4089 likely to be va_list, a typedef to __builtin_va_list, which
4090 is different enough that it will cause problems later. */
4091 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4092 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4094 rhs = build1 (NOP_EXPR, type, rhs);
4097 /* Arithmetic types all interconvert, and enum is treated like int. */
4098 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4099 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4100 || codel == BOOLEAN_TYPE)
4101 && (coder == INTEGER_TYPE || coder == REAL_TYPE
4102 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4103 || coder == BOOLEAN_TYPE))
4104 return convert_and_check (type, rhs);
4106 /* Conversion to a transparent union from its member types.
4107 This applies only to function arguments. */
4108 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4111 tree marginal_memb_type = 0;
4113 for (memb_types = TYPE_FIELDS (type); memb_types;
4114 memb_types = TREE_CHAIN (memb_types))
4116 tree memb_type = TREE_TYPE (memb_types);
4118 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4119 TYPE_MAIN_VARIANT (rhstype)))
4122 if (TREE_CODE (memb_type) != POINTER_TYPE)
4125 if (coder == POINTER_TYPE)
4127 register tree ttl = TREE_TYPE (memb_type);
4128 register tree ttr = TREE_TYPE (rhstype);
4130 /* Any non-function converts to a [const][volatile] void *
4131 and vice versa; otherwise, targets must be the same.
4132 Meanwhile, the lhs target must have all the qualifiers of
4134 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4135 || comp_target_types (memb_type, rhstype))
4137 /* If this type won't generate any warnings, use it. */
4138 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4139 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4140 && TREE_CODE (ttl) == FUNCTION_TYPE)
4141 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4142 == TYPE_QUALS (ttr))
4143 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4144 == TYPE_QUALS (ttl))))
4147 /* Keep looking for a better type, but remember this one. */
4148 if (! marginal_memb_type)
4149 marginal_memb_type = memb_type;
4153 /* Can convert integer zero to any pointer type. */
4154 if (integer_zerop (rhs)
4155 || (TREE_CODE (rhs) == NOP_EXPR
4156 && integer_zerop (TREE_OPERAND (rhs, 0))))
4158 rhs = null_pointer_node;
4163 if (memb_types || marginal_memb_type)
4167 /* We have only a marginally acceptable member type;
4168 it needs a warning. */
4169 register tree ttl = TREE_TYPE (marginal_memb_type);
4170 register tree ttr = TREE_TYPE (rhstype);
4172 /* Const and volatile mean something different for function
4173 types, so the usual warnings are not appropriate. */
4174 if (TREE_CODE (ttr) == FUNCTION_TYPE
4175 && TREE_CODE (ttl) == FUNCTION_TYPE)
4177 /* Because const and volatile on functions are
4178 restrictions that say the function will not do
4179 certain things, it is okay to use a const or volatile
4180 function where an ordinary one is wanted, but not
4182 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4183 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4184 errtype, funname, parmnum);
4186 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4187 warn_for_assignment ("%s discards qualifiers from pointer target type",
4192 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4193 pedwarn ("ISO C prohibits argument conversion to union type");
4195 return build1 (NOP_EXPR, type, rhs);
4199 /* Conversions among pointers */
4200 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4201 && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4203 register tree ttl = TREE_TYPE (type);
4204 register tree ttr = TREE_TYPE (rhstype);
4206 /* Any non-function converts to a [const][volatile] void *
4207 and vice versa; otherwise, targets must be the same.
4208 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4209 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4210 || comp_target_types (type, rhstype)
4211 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4212 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4215 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4218 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4219 which are not ANSI null ptr constants. */
4220 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4221 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4222 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4223 errtype, funname, parmnum);
4224 /* Const and volatile mean something different for function types,
4225 so the usual warnings are not appropriate. */
4226 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4227 && TREE_CODE (ttl) != FUNCTION_TYPE)
4229 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4230 warn_for_assignment ("%s discards qualifiers from pointer target type",
4231 errtype, funname, parmnum);
4232 /* If this is not a case of ignoring a mismatch in signedness,
4234 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4235 || comp_target_types (type, rhstype))
4237 /* If there is a mismatch, do warn. */
4239 warn_for_assignment ("pointer targets in %s differ in signedness",
4240 errtype, funname, parmnum);
4242 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4243 && TREE_CODE (ttr) == FUNCTION_TYPE)
4245 /* Because const and volatile on functions are restrictions
4246 that say the function will not do certain things,
4247 it is okay to use a const or volatile function
4248 where an ordinary one is wanted, but not vice-versa. */
4249 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4250 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4251 errtype, funname, parmnum);
4255 warn_for_assignment ("%s from incompatible pointer type",
4256 errtype, funname, parmnum);
4257 return convert (type, rhs);
4259 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4261 /* An explicit constant 0 can convert to a pointer,
4262 or one that results from arithmetic, even including
4263 a cast to integer type. */
4264 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4266 ! (TREE_CODE (rhs) == NOP_EXPR
4267 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4268 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4269 && integer_zerop (TREE_OPERAND (rhs, 0))))
4271 warn_for_assignment ("%s makes pointer from integer without a cast",
4272 errtype, funname, parmnum);
4273 return convert (type, rhs);
4275 return null_pointer_node;
4277 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4279 warn_for_assignment ("%s makes integer from pointer without a cast",
4280 errtype, funname, parmnum);
4281 return convert (type, rhs);
4283 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4284 return convert (type, rhs);
4290 tree selector = maybe_building_objc_message_expr ();
4292 if (selector && parmnum > 2)
4293 error ("incompatible type for argument %d of `%s'",
4294 parmnum - 2, IDENTIFIER_POINTER (selector));
4296 error ("incompatible type for argument %d of `%s'",
4297 parmnum, IDENTIFIER_POINTER (funname));
4300 error ("incompatible type for argument %d of indirect function call",
4304 error ("incompatible types in %s", errtype);
4306 return error_mark_node;
4309 /* Print a warning using MSGID.
4310 It gets OPNAME as its one parameter.
4311 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4312 FUNCTION and ARGNUM are handled specially if we are building an
4313 Objective-C selector. */
4316 warn_for_assignment (msgid, opname, function, argnum)
4324 tree selector = maybe_building_objc_message_expr ();
4327 if (selector && argnum > 2)
4329 function = selector;
4334 /* Function name is known; supply it. */
4335 const char *const argstring = _("passing arg %d of `%s'");
4336 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4337 + strlen (argstring) + 1 + 25
4339 sprintf (new_opname, argstring, argnum,
4340 IDENTIFIER_POINTER (function));
4344 /* Function name unknown (call through ptr); just give arg number.*/
4345 const char *const argnofun = _("passing arg %d of pointer to function");
4346 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4347 sprintf (new_opname, argnofun, argnum);
4349 opname = new_opname;
4351 pedwarn (msgid, opname);
4354 /* If VALUE is a compound expr all of whose expressions are constant, then
4355 return its value. Otherwise, return error_mark_node.
4357 This is for handling COMPOUND_EXPRs as initializer elements
4358 which is allowed with a warning when -pedantic is specified. */
4361 valid_compound_expr_initializer (value, endtype)
4365 if (TREE_CODE (value) == COMPOUND_EXPR)
4367 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4369 return error_mark_node;
4370 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4373 else if (! TREE_CONSTANT (value)
4374 && ! initializer_constant_valid_p (value, endtype))
4375 return error_mark_node;
4380 /* Perform appropriate conversions on the initial value of a variable,
4381 store it in the declaration DECL,
4382 and print any error messages that are appropriate.
4383 If the init is invalid, store an ERROR_MARK. */
4386 store_init_value (decl, init)
4389 register tree value, type;
4391 /* If variable's type was invalidly declared, just ignore it. */
4393 type = TREE_TYPE (decl);
4394 if (TREE_CODE (type) == ERROR_MARK)
4397 /* Digest the specified initializer into an expression. */
4399 value = digest_init (type, init, TREE_STATIC (decl),
4400 TREE_STATIC (decl) || (pedantic && !flag_isoc99));
4402 /* Store the expression if valid; else report error. */
4405 /* Note that this is the only place we can detect the error
4406 in a case such as struct foo bar = (struct foo) { x, y };
4407 where there is one initial value which is a constructor expression. */
4408 if (value == error_mark_node)
4410 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4412 error ("initializer for static variable is not constant");
4413 value = error_mark_node;
4415 else if (TREE_STATIC (decl)
4416 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4418 error ("initializer for static variable uses complicated arithmetic");
4419 value = error_mark_node;
4423 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4425 if (! TREE_CONSTANT (value))
4426 pedwarn ("aggregate initializer is not constant");
4427 else if (! TREE_STATIC (value))
4428 pedwarn ("aggregate initializer uses complicated arithmetic");
4433 if (warn_traditional && !in_system_header
4434 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4435 warning ("traditional C rejects automatic aggregate initialization");
4437 DECL_INITIAL (decl) = value;
4439 /* ANSI wants warnings about out-of-range constant initializers. */
4440 STRIP_TYPE_NOPS (value);
4441 constant_expression_warning (value);
4444 /* Methods for storing and printing names for error messages. */
4446 /* Implement a spelling stack that allows components of a name to be pushed
4447 and popped. Each element on the stack is this structure. */
4459 #define SPELLING_STRING 1
4460 #define SPELLING_MEMBER 2
4461 #define SPELLING_BOUNDS 3
4463 static struct spelling *spelling; /* Next stack element (unused). */
4464 static struct spelling *spelling_base; /* Spelling stack base. */
4465 static int spelling_size; /* Size of the spelling stack. */
4467 /* Macros to save and restore the spelling stack around push_... functions.
4468 Alternative to SAVE_SPELLING_STACK. */
4470 #define SPELLING_DEPTH() (spelling - spelling_base)
4471 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4473 /* Save and restore the spelling stack around arbitrary C code. */
4475 #define SAVE_SPELLING_DEPTH(code) \
4477 int __depth = SPELLING_DEPTH (); \
4479 RESTORE_SPELLING_DEPTH (__depth); \
4482 /* Push an element on the spelling stack with type KIND and assign VALUE
4485 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4487 int depth = SPELLING_DEPTH (); \
4489 if (depth >= spelling_size) \
4491 spelling_size += 10; \
4492 if (spelling_base == 0) \
4494 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4497 = (struct spelling *) xrealloc (spelling_base, \
4498 spelling_size * sizeof (struct spelling)); \
4499 RESTORE_SPELLING_DEPTH (depth); \
4502 spelling->kind = (KIND); \
4503 spelling->MEMBER = (VALUE); \
4507 /* Push STRING on the stack. Printed literally. */
4510 push_string (string)
4513 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4516 /* Push a member name on the stack. Printed as '.' STRING. */
4519 push_member_name (decl)
4523 const char *const string
4524 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4525 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4528 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4531 push_array_bounds (bounds)
4534 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4537 /* Compute the maximum size in bytes of the printed spelling. */
4542 register int size = 0;
4543 register struct spelling *p;
4545 for (p = spelling_base; p < spelling; p++)
4547 if (p->kind == SPELLING_BOUNDS)
4550 size += strlen (p->u.s) + 1;
4556 /* Print the spelling to BUFFER and return it. */
4559 print_spelling (buffer)
4560 register char *buffer;
4562 register char *d = buffer;
4563 register struct spelling *p;
4565 for (p = spelling_base; p < spelling; p++)
4566 if (p->kind == SPELLING_BOUNDS)
4568 sprintf (d, "[%d]", p->u.i);
4573 register const char *s;
4574 if (p->kind == SPELLING_MEMBER)
4576 for (s = p->u.s; (*d = *s++); d++)
4583 /* Issue an error message for a bad initializer component.
4584 MSGID identifies the message.
4585 The component name is taken from the spelling stack. */
4593 error ("%s", msgid);
4594 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4596 error ("(near initialization for `%s')", ofwhat);
4599 /* Issue a pedantic warning for a bad initializer component.
4600 MSGID identifies the message.
4601 The component name is taken from the spelling stack. */
4604 pedwarn_init (msgid)
4609 pedwarn ("%s", msgid);
4610 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4612 pedwarn ("(near initialization for `%s')", ofwhat);
4615 /* Issue a warning for a bad initializer component.
4616 MSGID identifies the message.
4617 The component name is taken from the spelling stack. */
4620 warning_init (msgid)
4625 warning ("%s", msgid);
4626 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4628 warning ("(near initialization for `%s')", ofwhat);
4631 /* Digest the parser output INIT as an initializer for type TYPE.
4632 Return a C expression of type TYPE to represent the initial value.
4634 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4635 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4636 applies only to elements of constructors. */
4639 digest_init (type, init, require_constant, constructor_constant)
4641 int require_constant, constructor_constant;
4643 enum tree_code code = TREE_CODE (type);
4644 tree inside_init = init;
4646 if (type == error_mark_node
4647 || init == error_mark_node
4648 || TREE_TYPE (init) == error_mark_node)
4649 return error_mark_node;
4651 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4652 /* Do not use STRIP_NOPS here. We do not want an enumerator
4653 whose value is 0 to count as a null pointer constant. */
4654 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4655 inside_init = TREE_OPERAND (init, 0);
4657 inside_init = fold (inside_init);
4659 /* Initialization of an array of chars from a string constant
4660 optionally enclosed in braces. */
4662 if (code == ARRAY_TYPE)
4664 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4665 if ((typ1 == char_type_node
4666 || typ1 == signed_char_type_node
4667 || typ1 == unsigned_char_type_node
4668 || typ1 == unsigned_wchar_type_node
4669 || typ1 == signed_wchar_type_node)
4670 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4672 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4673 TYPE_MAIN_VARIANT (type)))
4676 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4678 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4680 error_init ("char-array initialized from wide string");
4681 return error_mark_node;
4683 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4685 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4687 error_init ("int-array initialized from non-wide string");
4688 return error_mark_node;
4691 TREE_TYPE (inside_init) = type;
4692 if (TYPE_DOMAIN (type) != 0
4693 && TYPE_SIZE (type) != 0
4694 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4695 /* Subtract 1 (or sizeof (wchar_t))
4696 because it's ok to ignore the terminating null char
4697 that is counted in the length of the constant. */
4698 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4699 TREE_STRING_LENGTH (inside_init)
4700 - ((TYPE_PRECISION (typ1)
4701 != TYPE_PRECISION (char_type_node))
4702 ? (TYPE_PRECISION (wchar_type_node)
4705 pedwarn_init ("initializer-string for array of chars is too long");
4711 /* Any type can be initialized
4712 from an expression of the same type, optionally with braces. */
4714 if (inside_init && TREE_TYPE (inside_init) != 0
4715 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4716 TYPE_MAIN_VARIANT (type))
4717 || (code == ARRAY_TYPE
4718 && comptypes (TREE_TYPE (inside_init), type))
4719 || (code == POINTER_TYPE
4720 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4721 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4722 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4723 TREE_TYPE (type)))))
4725 if (code == POINTER_TYPE
4726 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4727 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4728 inside_init = default_conversion (inside_init);
4729 else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4730 && TREE_CODE (inside_init) != CONSTRUCTOR)
4732 error_init ("array initialized from non-constant array expression");
4733 return error_mark_node;
4736 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4737 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4739 /* Compound expressions can only occur here if -pedantic or
4740 -pedantic-errors is specified. In the later case, we always want
4741 an error. In the former case, we simply want a warning. */
4742 if (require_constant && pedantic
4743 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4746 = valid_compound_expr_initializer (inside_init,
4747 TREE_TYPE (inside_init));
4748 if (inside_init == error_mark_node)
4749 error_init ("initializer element is not constant");
4751 pedwarn_init ("initializer element is not constant");
4752 if (flag_pedantic_errors)
4753 inside_init = error_mark_node;
4755 else if (require_constant
4756 && (!TREE_CONSTANT (inside_init)
4757 /* This test catches things like `7 / 0' which
4758 result in an expression for which TREE_CONSTANT
4759 is true, but which is not actually something
4760 that is a legal constant. We really should not
4761 be using this function, because it is a part of
4762 the back-end. Instead, the expression should
4763 already have been turned into ERROR_MARK_NODE. */
4764 || !initializer_constant_valid_p (inside_init,
4765 TREE_TYPE (inside_init))))
4767 error_init ("initializer element is not constant");
4768 inside_init = error_mark_node;
4774 /* Handle scalar types, including conversions. */
4776 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4777 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4779 /* Note that convert_for_assignment calls default_conversion
4780 for arrays and functions. We must not call it in the
4781 case where inside_init is a null pointer constant. */
4783 = convert_for_assignment (type, init, _("initialization"),
4784 NULL_TREE, NULL_TREE, 0);
4786 if (require_constant && ! TREE_CONSTANT (inside_init))
4788 error_init ("initializer element is not constant");
4789 inside_init = error_mark_node;
4791 else if (require_constant
4792 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4794 error_init ("initializer element is not computable at load time");
4795 inside_init = error_mark_node;
4801 /* Come here only for records and arrays. */
4803 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4805 error_init ("variable-sized object may not be initialized");
4806 return error_mark_node;
4809 /* Traditionally, you can write struct foo x = 0;
4810 and it initializes the first element of x to 0. */
4811 if (flag_traditional)
4813 tree top = 0, prev = 0, otype = type;
4814 while (TREE_CODE (type) == RECORD_TYPE
4815 || TREE_CODE (type) == ARRAY_TYPE
4816 || TREE_CODE (type) == QUAL_UNION_TYPE
4817 || TREE_CODE (type) == UNION_TYPE)
4819 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4823 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4825 if (TREE_CODE (type) == ARRAY_TYPE)
4826 type = TREE_TYPE (type);
4827 else if (TYPE_FIELDS (type))
4828 type = TREE_TYPE (TYPE_FIELDS (type));
4831 error_init ("invalid initializer");
4832 return error_mark_node;
4838 TREE_OPERAND (prev, 1)
4839 = build_tree_list (NULL_TREE,
4840 digest_init (type, init, require_constant,
4841 constructor_constant));
4845 return error_mark_node;
4847 error_init ("invalid initializer");
4848 return error_mark_node;
4851 /* Handle initializers that use braces. */
4853 /* Type of object we are accumulating a constructor for.
4854 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4855 static tree constructor_type;
4857 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4859 static tree constructor_fields;
4861 /* For an ARRAY_TYPE, this is the specified index
4862 at which to store the next element we get. */
4863 static tree constructor_index;
4865 /* For an ARRAY_TYPE, this is the maximum index. */
4866 static tree constructor_max_index;
4868 /* For a RECORD_TYPE, this is the first field not yet written out. */
4869 static tree constructor_unfilled_fields;
4871 /* For an ARRAY_TYPE, this is the index of the first element
4872 not yet written out. */
4873 static tree constructor_unfilled_index;
4875 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4876 This is so we can generate gaps between fields, when appropriate. */
4877 static tree constructor_bit_index;
4879 /* If we are saving up the elements rather than allocating them,
4880 this is the list of elements so far (in reverse order,
4881 most recent first). */
4882 static tree constructor_elements;
4884 /* 1 if constructor should be incrementally stored into a constructor chain,
4885 0 if all the elements should be kept in AVL tree. */
4886 static int constructor_incremental;
4888 /* 1 if so far this constructor's elements are all compile-time constants. */
4889 static int constructor_constant;
4891 /* 1 if so far this constructor's elements are all valid address constants. */
4892 static int constructor_simple;
4894 /* 1 if this constructor is erroneous so far. */
4895 static int constructor_erroneous;
4897 /* 1 if have called defer_addressed_constants. */
4898 static int constructor_subconstants_deferred;
4900 /* Structure for managing pending initializer elements, organized as an
4905 struct init_node *left, *right;
4906 struct init_node *parent;
4912 /* Tree of pending elements at this constructor level.
4913 These are elements encountered out of order
4914 which belong at places we haven't reached yet in actually
4916 Will never hold tree nodes across GC runs. */
4917 static struct init_node *constructor_pending_elts;
4919 /* The SPELLING_DEPTH of this constructor. */
4920 static int constructor_depth;
4922 /* 0 if implicitly pushing constructor levels is allowed. */
4923 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4925 static int require_constant_value;
4926 static int require_constant_elements;
4928 /* DECL node for which an initializer is being read.
4929 0 means we are reading a constructor expression
4930 such as (struct foo) {...}. */
4931 static tree constructor_decl;
4933 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4934 static const char *constructor_asmspec;
4936 /* Nonzero if this is an initializer for a top-level decl. */
4937 static int constructor_top_level;
4939 /* Nesting depth of designator list. */
4940 static int designator_depth;
4942 /* Nonzero if there were diagnosed errors in this designator list. */
4943 static int designator_errorneous;
4946 /* This stack has a level for each implicit or explicit level of
4947 structuring in the initializer, including the outermost one. It
4948 saves the values of most of the variables above. */
4950 struct constructor_range_stack;
4952 struct constructor_stack
4954 struct constructor_stack *next;
4959 tree unfilled_index;
4960 tree unfilled_fields;
4963 struct init_node *pending_elts;
4966 /* If nonzero, this value should replace the entire
4967 constructor at this level. */
4968 tree replacement_value;
4969 struct constructor_range_stack *range_stack;
4978 struct constructor_stack *constructor_stack;
4980 /* This stack represents designators from some range designator up to
4981 the last designator in the list. */
4983 struct constructor_range_stack
4985 struct constructor_range_stack *next, *prev;
4986 struct constructor_stack *stack;
4993 struct constructor_range_stack *constructor_range_stack;
4995 /* This stack records separate initializers that are nested.
4996 Nested initializers can't happen in ANSI C, but GNU C allows them
4997 in cases like { ... (struct foo) { ... } ... }. */
4999 struct initializer_stack
5001 struct initializer_stack *next;
5003 const char *asmspec;
5004 struct constructor_stack *constructor_stack;
5005 struct constructor_range_stack *constructor_range_stack;
5007 struct spelling *spelling;
5008 struct spelling *spelling_base;
5011 char require_constant_value;
5012 char require_constant_elements;
5016 struct initializer_stack *initializer_stack;
5018 /* Prepare to parse and output the initializer for variable DECL. */
5021 start_init (decl, asmspec_tree, top_level)
5027 struct initializer_stack *p
5028 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5029 const char *asmspec = 0;
5032 asmspec = TREE_STRING_POINTER (asmspec_tree);
5034 p->decl = constructor_decl;
5035 p->asmspec = constructor_asmspec;
5036 p->require_constant_value = require_constant_value;
5037 p->require_constant_elements = require_constant_elements;
5038 p->constructor_stack = constructor_stack;
5039 p->constructor_range_stack = constructor_range_stack;
5040 p->elements = constructor_elements;
5041 p->spelling = spelling;
5042 p->spelling_base = spelling_base;
5043 p->spelling_size = spelling_size;
5044 p->deferred = constructor_subconstants_deferred;
5045 p->top_level = constructor_top_level;
5046 p->next = initializer_stack;
5047 initializer_stack = p;
5049 constructor_decl = decl;
5050 constructor_asmspec = asmspec;
5051 constructor_subconstants_deferred = 0;
5052 constructor_top_level = top_level;
5056 require_constant_value = TREE_STATIC (decl);
5057 require_constant_elements
5058 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5059 /* For a scalar, you can always use any value to initialize,
5060 even within braces. */
5061 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5062 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5063 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5064 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5065 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5069 require_constant_value = 0;
5070 require_constant_elements = 0;
5071 locus = "(anonymous)";
5074 constructor_stack = 0;
5075 constructor_range_stack = 0;
5077 missing_braces_mentioned = 0;
5081 RESTORE_SPELLING_DEPTH (0);
5084 push_string (locus);
5090 struct initializer_stack *p = initializer_stack;
5092 /* Output subconstants (string constants, usually)
5093 that were referenced within this initializer and saved up.
5094 Must do this if and only if we called defer_addressed_constants. */
5095 if (constructor_subconstants_deferred)
5096 output_deferred_addressed_constants ();
5098 /* Free the whole constructor stack of this initializer. */
5099 while (constructor_stack)
5101 struct constructor_stack *q = constructor_stack;
5102 constructor_stack = q->next;
5106 if (constructor_range_stack)
5109 /* Pop back to the data of the outer initializer (if any). */
5110 constructor_decl = p->decl;
5111 constructor_asmspec = p->asmspec;
5112 require_constant_value = p->require_constant_value;
5113 require_constant_elements = p->require_constant_elements;
5114 constructor_stack = p->constructor_stack;
5115 constructor_range_stack = p->constructor_range_stack;
5116 constructor_elements = p->elements;
5117 spelling = p->spelling;
5118 spelling_base = p->spelling_base;
5119 spelling_size = p->spelling_size;
5120 constructor_subconstants_deferred = p->deferred;
5121 constructor_top_level = p->top_level;
5122 initializer_stack = p->next;
5126 /* Call here when we see the initializer is surrounded by braces.
5127 This is instead of a call to push_init_level;
5128 it is matched by a call to pop_init_level.
5130 TYPE is the type to initialize, for a constructor expression.
5131 For an initializer for a decl, TYPE is zero. */
5134 really_start_incremental_init (type)
5137 struct constructor_stack *p
5138 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5141 type = TREE_TYPE (constructor_decl);
5143 p->type = constructor_type;
5144 p->fields = constructor_fields;
5145 p->index = constructor_index;
5146 p->max_index = constructor_max_index;
5147 p->unfilled_index = constructor_unfilled_index;
5148 p->unfilled_fields = constructor_unfilled_fields;
5149 p->bit_index = constructor_bit_index;
5150 p->elements = constructor_elements;
5151 p->constant = constructor_constant;
5152 p->simple = constructor_simple;
5153 p->erroneous = constructor_erroneous;
5154 p->pending_elts = constructor_pending_elts;
5155 p->depth = constructor_depth;
5156 p->replacement_value = 0;
5160 p->incremental = constructor_incremental;
5162 constructor_stack = p;
5164 constructor_constant = 1;
5165 constructor_simple = 1;
5166 constructor_depth = SPELLING_DEPTH ();
5167 constructor_elements = 0;
5168 constructor_pending_elts = 0;
5169 constructor_type = type;
5170 constructor_incremental = 1;
5171 designator_depth = 0;
5172 designator_errorneous = 0;
5174 if (TREE_CODE (constructor_type) == RECORD_TYPE
5175 || TREE_CODE (constructor_type) == UNION_TYPE)
5177 constructor_fields = TYPE_FIELDS (constructor_type);
5178 /* Skip any nameless bit fields at the beginning. */
5179 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5180 && DECL_NAME (constructor_fields) == 0)
5181 constructor_fields = TREE_CHAIN (constructor_fields);
5183 constructor_unfilled_fields = constructor_fields;
5184 constructor_bit_index = bitsize_zero_node;
5186 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5188 if (TYPE_DOMAIN (constructor_type))
5190 constructor_max_index
5191 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5193 /* Detect non-empty initializations of zero-length arrays. */
5194 if (constructor_max_index == NULL_TREE
5195 && TYPE_SIZE (constructor_type))
5196 constructor_max_index = build_int_2 (-1, -1);
5199 = convert (bitsizetype,
5200 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5203 constructor_index = bitsize_zero_node;
5205 constructor_unfilled_index = constructor_index;
5209 /* Handle the case of int x = {5}; */
5210 constructor_fields = constructor_type;
5211 constructor_unfilled_fields = constructor_type;
5215 /* Push down into a subobject, for initialization.
5216 If this is for an explicit set of braces, IMPLICIT is 0.
5217 If it is because the next element belongs at a lower level,
5218 IMPLICIT is 1 (or 2 if the push is because of designator list). */
5221 push_init_level (implicit)
5224 struct constructor_stack *p;
5225 tree value = NULL_TREE;
5227 /* If we've exhausted any levels that didn't have braces,
5229 while (constructor_stack->implicit)
5231 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5232 || TREE_CODE (constructor_type) == UNION_TYPE)
5233 && constructor_fields == 0)
5234 process_init_element (pop_init_level (1));
5235 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5236 && tree_int_cst_lt (constructor_max_index, constructor_index))
5237 process_init_element (pop_init_level (1));
5242 /* Unless this is an explicit brace, we need to preserve previous
5246 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5247 || TREE_CODE (constructor_type) == UNION_TYPE)
5248 && constructor_fields)
5249 value = find_init_member (constructor_fields);
5250 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5251 value = find_init_member (constructor_index);
5254 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5255 p->type = constructor_type;
5256 p->fields = constructor_fields;
5257 p->index = constructor_index;
5258 p->max_index = constructor_max_index;
5259 p->unfilled_index = constructor_unfilled_index;
5260 p->unfilled_fields = constructor_unfilled_fields;
5261 p->bit_index = constructor_bit_index;
5262 p->elements = constructor_elements;
5263 p->constant = constructor_constant;
5264 p->simple = constructor_simple;
5265 p->erroneous = constructor_erroneous;
5266 p->pending_elts = constructor_pending_elts;
5267 p->depth = constructor_depth;
5268 p->replacement_value = 0;
5269 p->implicit = implicit;
5271 p->incremental = constructor_incremental;
5272 p->next = constructor_stack;
5274 constructor_stack = p;
5276 constructor_constant = 1;
5277 constructor_simple = 1;
5278 constructor_depth = SPELLING_DEPTH ();
5279 constructor_elements = 0;
5280 constructor_incremental = 1;
5281 constructor_pending_elts = 0;
5284 p->range_stack = constructor_range_stack;
5285 constructor_range_stack = 0;
5286 designator_depth = 0;
5287 designator_errorneous = 0;
5290 /* Don't die if an entire brace-pair level is superfluous
5291 in the containing level. */
5292 if (constructor_type == 0)
5294 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5295 || TREE_CODE (constructor_type) == UNION_TYPE)
5297 /* Don't die if there are extra init elts at the end. */
5298 if (constructor_fields == 0)
5299 constructor_type = 0;
5302 constructor_type = TREE_TYPE (constructor_fields);
5303 push_member_name (constructor_fields);
5304 constructor_depth++;
5307 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5309 constructor_type = TREE_TYPE (constructor_type);
5310 push_array_bounds (tree_low_cst (constructor_index, 0));
5311 constructor_depth++;
5314 if (constructor_type == 0)
5316 error_init ("extra brace group at end of initializer");
5317 constructor_fields = 0;
5318 constructor_unfilled_fields = 0;
5322 if (value && TREE_CODE (value) == CONSTRUCTOR)
5324 constructor_constant = TREE_CONSTANT (value);
5325 constructor_simple = TREE_STATIC (value);
5326 constructor_elements = TREE_OPERAND (value, 1);
5327 if (constructor_elements
5328 && (TREE_CODE (constructor_type) == RECORD_TYPE
5329 || TREE_CODE (constructor_type) == ARRAY_TYPE))
5330 set_nonincremental_init ();
5333 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5335 missing_braces_mentioned = 1;
5336 warning_init ("missing braces around initializer");
5339 if (TREE_CODE (constructor_type) == RECORD_TYPE
5340 || TREE_CODE (constructor_type) == UNION_TYPE)
5342 constructor_fields = TYPE_FIELDS (constructor_type);
5343 /* Skip any nameless bit fields at the beginning. */
5344 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5345 && DECL_NAME (constructor_fields) == 0)
5346 constructor_fields = TREE_CHAIN (constructor_fields);
5348 constructor_unfilled_fields = constructor_fields;
5349 constructor_bit_index = bitsize_zero_node;
5351 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5353 if (TYPE_DOMAIN (constructor_type))
5355 constructor_max_index
5356 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5358 /* Detect non-empty initializations of zero-length arrays. */
5359 if (constructor_max_index == NULL_TREE
5360 && TYPE_SIZE (constructor_type))
5361 constructor_max_index = build_int_2 (-1, -1);
5364 = convert (bitsizetype,
5365 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5368 constructor_index = bitsize_zero_node;
5370 constructor_unfilled_index = constructor_index;
5371 if (value && TREE_CODE (value) == STRING_CST)
5373 /* We need to split the char/wchar array into individual
5374 characters, so that we don't have to special case it
5376 set_nonincremental_init_from_string (value);
5381 warning_init ("braces around scalar initializer");
5382 constructor_fields = constructor_type;
5383 constructor_unfilled_fields = constructor_type;
5387 /* At the end of an implicit or explicit brace level,
5388 finish up that level of constructor.
5389 If we were outputting the elements as they are read, return 0
5390 from inner levels (process_init_element ignores that),
5391 but return error_mark_node from the outermost level
5392 (that's what we want to put in DECL_INITIAL).
5393 Otherwise, return a CONSTRUCTOR expression. */
5396 pop_init_level (implicit)
5399 struct constructor_stack *p;
5400 HOST_WIDE_INT size = 0;
5401 tree constructor = 0;
5405 /* When we come to an explicit close brace,
5406 pop any inner levels that didn't have explicit braces. */
5407 while (constructor_stack->implicit)
5408 process_init_element (pop_init_level (1));
5410 if (constructor_range_stack)
5414 p = constructor_stack;
5416 if (constructor_type != 0)
5417 size = int_size_in_bytes (constructor_type);
5419 /* Error for initializing a flexible array member, or a zero-length
5420 array member in an inappropriate context. */
5421 if (constructor_type && constructor_fields
5422 && TREE_CODE (constructor_type) == ARRAY_TYPE
5423 && TYPE_DOMAIN (constructor_type)
5424 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5426 /* Silently discard empty initializations. The parser will
5427 already have pedwarned for empty brackets. */
5428 if (integer_zerop (constructor_unfilled_index))
5429 constructor_type = NULL_TREE;
5430 else if (! TYPE_SIZE (constructor_type))
5432 if (constructor_depth > 2)
5433 error_init ("initialization of flexible array member in a nested context");
5435 pedwarn_init ("initialization of a flexible array member");
5437 /* We have already issued an error message for the existance
5438 of a flexible array member not at the end of the structure.
5439 Discard the initializer so that we do not abort later. */
5440 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5441 constructor_type = NULL_TREE;
5444 /* Zero-length arrays are no longer special, so we should no longer
5449 /* Warn when some struct elements are implicitly initialized to zero. */
5452 && TREE_CODE (constructor_type) == RECORD_TYPE
5453 && constructor_unfilled_fields)
5455 /* Do not warn for flexible array members or zero-length arrays. */
5456 while (constructor_unfilled_fields
5457 && (! DECL_SIZE (constructor_unfilled_fields)
5458 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5459 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5461 if (constructor_unfilled_fields)
5463 push_member_name (constructor_unfilled_fields);
5464 warning_init ("missing initializer");
5465 RESTORE_SPELLING_DEPTH (constructor_depth);
5469 /* Now output all pending elements. */
5470 constructor_incremental = 1;
5471 output_pending_init_elements (1);
5473 /* Pad out the end of the structure. */
5474 if (p->replacement_value)
5475 /* If this closes a superfluous brace pair,
5476 just pass out the element between them. */
5477 constructor = p->replacement_value;
5478 else if (constructor_type == 0)
5480 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5481 && TREE_CODE (constructor_type) != UNION_TYPE
5482 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5484 /* A nonincremental scalar initializer--just return
5485 the element, after verifying there is just one. */
5486 if (constructor_elements == 0)
5488 if (!constructor_erroneous)
5489 error_init ("empty scalar initializer");
5490 constructor = error_mark_node;
5492 else if (TREE_CHAIN (constructor_elements) != 0)
5494 error_init ("extra elements in scalar initializer");
5495 constructor = TREE_VALUE (constructor_elements);
5498 constructor = TREE_VALUE (constructor_elements);
5502 if (constructor_erroneous)
5503 constructor = error_mark_node;
5506 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5507 nreverse (constructor_elements));
5508 if (constructor_constant)
5509 TREE_CONSTANT (constructor) = 1;
5510 if (constructor_constant && constructor_simple)
5511 TREE_STATIC (constructor) = 1;
5515 constructor_type = p->type;
5516 constructor_fields = p->fields;
5517 constructor_index = p->index;
5518 constructor_max_index = p->max_index;
5519 constructor_unfilled_index = p->unfilled_index;
5520 constructor_unfilled_fields = p->unfilled_fields;
5521 constructor_bit_index = p->bit_index;
5522 constructor_elements = p->elements;
5523 constructor_constant = p->constant;
5524 constructor_simple = p->simple;
5525 constructor_erroneous = p->erroneous;
5526 constructor_incremental = p->incremental;
5527 constructor_pending_elts = p->pending_elts;
5528 constructor_depth = p->depth;
5530 constructor_range_stack = p->range_stack;
5531 RESTORE_SPELLING_DEPTH (constructor_depth);
5533 constructor_stack = p->next;
5536 if (constructor == 0)
5538 if (constructor_stack == 0)
5539 return error_mark_node;
5545 /* Common handling for both array range and field name designators.
5546 ARRAY argument is non-zero for array ranges. Returns zero for success. */
5549 set_designator (array)
5553 enum tree_code subcode;
5555 /* Don't die if an entire brace-pair level is superfluous
5556 in the containing level. */
5557 if (constructor_type == 0)
5560 /* If there were errors in this designator list already, bail out silently. */
5561 if (designator_errorneous)
5564 if (!designator_depth)
5566 if (constructor_range_stack)
5569 /* Designator list starts at the level of closest explicit
5571 while (constructor_stack->implicit)
5572 process_init_element (pop_init_level (1));
5576 if (constructor_no_implicit)
5578 error_init ("initialization designators may not nest");
5582 if (TREE_CODE (constructor_type) == RECORD_TYPE
5583 || TREE_CODE (constructor_type) == UNION_TYPE)
5585 subtype = TREE_TYPE (constructor_fields);
5586 if (subtype != error_mark_node)
5587 subtype = TYPE_MAIN_VARIANT (subtype);
5589 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5591 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5596 subcode = TREE_CODE (subtype);
5597 if (array && subcode != ARRAY_TYPE)
5599 error_init ("array index in non-array initializer");
5602 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5604 error_init ("field name not in record or union initializer");
5608 push_init_level (2);
5612 /* If there are range designators in designator list, push a new designator
5613 to constructor_range_stack. RANGE_END is end of such stack range or
5614 NULL_TREE if there is no range designator at this level. */
5617 push_range_stack (range_end)
5620 struct constructor_range_stack *p;
5622 p = (struct constructor_range_stack *)
5623 ggc_alloc (sizeof (struct constructor_range_stack));
5624 p->prev = constructor_range_stack;
5626 p->fields = constructor_fields;
5627 p->range_start = constructor_index;
5628 p->index = constructor_index;
5629 p->stack = constructor_stack;
5630 p->range_end = range_end;
5631 if (constructor_range_stack)
5632 constructor_range_stack->next = p;
5633 constructor_range_stack = p;
5636 /* Within an array initializer, specify the next index to be initialized.
5637 FIRST is that index. If LAST is nonzero, then initialize a range
5638 of indices, running from FIRST through LAST. */
5641 set_init_index (first, last)
5644 if (set_designator (1))
5647 designator_errorneous = 1;
5649 while ((TREE_CODE (first) == NOP_EXPR
5650 || TREE_CODE (first) == CONVERT_EXPR
5651 || TREE_CODE (first) == NON_LVALUE_EXPR)
5652 && (TYPE_MODE (TREE_TYPE (first))
5653 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5654 first = TREE_OPERAND (first, 0);
5657 while ((TREE_CODE (last) == NOP_EXPR
5658 || TREE_CODE (last) == CONVERT_EXPR
5659 || TREE_CODE (last) == NON_LVALUE_EXPR)
5660 && (TYPE_MODE (TREE_TYPE (last))
5661 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5662 last = TREE_OPERAND (last, 0);
5664 if (TREE_CODE (first) != INTEGER_CST)
5665 error_init ("nonconstant array index in initializer");
5666 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5667 error_init ("nonconstant array index in initializer");
5668 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5669 error_init ("array index in non-array initializer");
5670 else if (constructor_max_index
5671 && tree_int_cst_lt (constructor_max_index, first))
5672 error_init ("array index in initializer exceeds array bounds");
5675 constructor_index = convert (bitsizetype, first);
5679 if (tree_int_cst_equal (first, last))
5681 else if (tree_int_cst_lt (last, first))
5683 error_init ("empty index range in initializer");
5688 last = convert (bitsizetype, last);
5689 if (constructor_max_index != 0
5690 && tree_int_cst_lt (constructor_max_index, last))
5692 error_init ("array index range in initializer exceeds array bounds");
5699 designator_errorneous = 0;
5700 if (constructor_range_stack || last)
5701 push_range_stack (last);
5705 /* Within a struct initializer, specify the next field to be initialized. */
5708 set_init_label (fieldname)
5713 if (set_designator (0))
5716 designator_errorneous = 1;
5718 if (TREE_CODE (constructor_type) != RECORD_TYPE
5719 && TREE_CODE (constructor_type) != UNION_TYPE)
5721 error_init ("field name not in record or union initializer");
5725 for (tail = TYPE_FIELDS (constructor_type); tail;
5726 tail = TREE_CHAIN (tail))
5728 if (DECL_NAME (tail) == fieldname)
5733 error ("unknown field `%s' specified in initializer",
5734 IDENTIFIER_POINTER (fieldname));
5737 constructor_fields = tail;
5739 designator_errorneous = 0;
5740 if (constructor_range_stack)
5741 push_range_stack (NULL_TREE);
5745 /* Add a new initializer to the tree of pending initializers. PURPOSE
5746 indentifies the initializer, either array index or field in a structure.
5747 VALUE is the value of that index or field. */
5750 add_pending_init (purpose, value)
5751 tree purpose, value;
5753 struct init_node *p, **q, *r;
5755 q = &constructor_pending_elts;
5758 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5763 if (tree_int_cst_lt (purpose, p->purpose))
5765 else if (tree_int_cst_lt (p->purpose, purpose))
5769 if (TREE_SIDE_EFFECTS (p->value))
5770 warning_init ("initialized field with side-effects overwritten");
5780 bitpos = bit_position (purpose);
5784 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5786 else if (p->purpose != purpose)
5790 if (TREE_SIDE_EFFECTS (p->value))
5791 warning_init ("initialized field with side-effects overwritten");
5798 r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5799 r->purpose = purpose;
5810 struct init_node *s;
5814 if (p->balance == 0)
5816 else if (p->balance < 0)
5823 p->left->parent = p;
5840 constructor_pending_elts = r;
5845 struct init_node *t = r->right;
5849 r->right->parent = r;
5854 p->left->parent = p;
5857 p->balance = t->balance < 0;
5858 r->balance = -(t->balance > 0);
5873 constructor_pending_elts = t;
5879 /* p->balance == +1; growth of left side balances the node. */
5884 else /* r == p->right */
5886 if (p->balance == 0)
5887 /* Growth propagation from right side. */
5889 else if (p->balance > 0)
5896 p->right->parent = p;
5913 constructor_pending_elts = r;
5915 else /* r->balance == -1 */
5918 struct init_node *t = r->left;
5922 r->left->parent = r;
5927 p->right->parent = p;
5930 r->balance = (t->balance < 0);
5931 p->balance = -(t->balance > 0);
5946 constructor_pending_elts = t;
5952 /* p->balance == -1; growth of right side balances the node. */
5963 /* Build AVL tree from a sorted chain. */
5966 set_nonincremental_init ()
5970 if (TREE_CODE (constructor_type) != RECORD_TYPE
5971 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5974 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5975 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5976 constructor_elements = 0;
5977 if (TREE_CODE (constructor_type) == RECORD_TYPE)
5979 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5980 /* Skip any nameless bit fields at the beginning. */
5981 while (constructor_unfilled_fields != 0
5982 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5983 && DECL_NAME (constructor_unfilled_fields) == 0)
5984 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5987 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5989 if (TYPE_DOMAIN (constructor_type))
5990 constructor_unfilled_index
5991 = convert (bitsizetype,
5992 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5994 constructor_unfilled_index = bitsize_zero_node;
5996 constructor_incremental = 0;
5999 /* Build AVL tree from a string constant. */
6002 set_nonincremental_init_from_string (str)
6005 tree value, purpose, type;
6006 HOST_WIDE_INT val[2];
6007 const char *p, *end;
6008 int byte, wchar_bytes, charwidth, bitpos;
6010 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6013 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6014 == TYPE_PRECISION (char_type_node))
6016 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6017 == TYPE_PRECISION (wchar_type_node))
6018 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6022 charwidth = TYPE_PRECISION (char_type_node);
6023 type = TREE_TYPE (constructor_type);
6024 p = TREE_STRING_POINTER (str);
6025 end = p + TREE_STRING_LENGTH (str);
6027 for (purpose = bitsize_zero_node;
6028 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6029 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6031 if (wchar_bytes == 1)
6033 val[1] = (unsigned char) *p++;
6040 for (byte = 0; byte < wchar_bytes; byte++)
6042 if (BYTES_BIG_ENDIAN)
6043 bitpos = (wchar_bytes - byte - 1) * charwidth;
6045 bitpos = byte * charwidth;
6046 val[bitpos < HOST_BITS_PER_WIDE_INT]
6047 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6048 << (bitpos % HOST_BITS_PER_WIDE_INT);
6052 if (!TREE_UNSIGNED (type))
6054 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6055 if (bitpos < HOST_BITS_PER_WIDE_INT)
6057 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6059 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6063 else if (bitpos == HOST_BITS_PER_WIDE_INT)
6068 else if (val[0] & (((HOST_WIDE_INT) 1)
6069 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6070 val[0] |= ((HOST_WIDE_INT) -1)
6071 << (bitpos - HOST_BITS_PER_WIDE_INT);
6074 value = build_int_2 (val[1], val[0]);
6075 TREE_TYPE (value) = type;
6076 add_pending_init (purpose, value);
6079 constructor_incremental = 0;
6082 /* Return value of FIELD in pending initializer or zero if the field was
6083 not initialized yet. */
6086 find_init_member (field)
6089 struct init_node *p;
6091 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6093 if (constructor_incremental
6094 && tree_int_cst_lt (field, constructor_unfilled_index))
6095 set_nonincremental_init ();
6097 p = constructor_pending_elts;
6100 if (tree_int_cst_lt (field, p->purpose))
6102 else if (tree_int_cst_lt (p->purpose, field))
6108 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6110 tree bitpos = bit_position (field);
6112 if (constructor_incremental
6113 && (!constructor_unfilled_fields
6114 || tree_int_cst_lt (bitpos,
6115 bit_position (constructor_unfilled_fields))))
6116 set_nonincremental_init ();
6118 p = constructor_pending_elts;
6121 if (field == p->purpose)
6123 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6129 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6131 if (constructor_elements
6132 && TREE_PURPOSE (constructor_elements) == field)
6133 return TREE_VALUE (constructor_elements);
6138 /* "Output" the next constructor element.
6139 At top level, really output it to assembler code now.
6140 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6141 TYPE is the data type that the containing data type wants here.
6142 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6144 PENDING if non-nil means output pending elements that belong
6145 right after this element. (PENDING is normally 1;
6146 it is 0 while outputting pending elements, to avoid recursion.) */
6149 output_init_element (value, type, field, pending)
6150 tree value, type, field;
6153 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6154 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6155 && !(TREE_CODE (value) == STRING_CST
6156 && TREE_CODE (type) == ARRAY_TYPE
6157 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6158 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6159 TYPE_MAIN_VARIANT (type))))
6160 value = default_conversion (value);
6162 if (value == error_mark_node)
6163 constructor_erroneous = 1;
6164 else if (!TREE_CONSTANT (value))
6165 constructor_constant = 0;
6166 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6167 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6168 || TREE_CODE (constructor_type) == UNION_TYPE)
6169 && DECL_C_BIT_FIELD (field)
6170 && TREE_CODE (value) != INTEGER_CST))
6171 constructor_simple = 0;
6173 if (require_constant_value && ! TREE_CONSTANT (value))
6175 error_init ("initializer element is not constant");
6176 value = error_mark_node;
6178 else if (require_constant_elements
6179 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6180 pedwarn ("initializer element is not computable at load time");
6182 /* If this field is empty (and not at the end of structure),
6183 don't do anything other than checking the initializer. */
6185 && (TREE_TYPE (field) == error_mark_node
6186 || (COMPLETE_TYPE_P (TREE_TYPE (field))
6187 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6188 && (TREE_CODE (constructor_type) == ARRAY_TYPE
6189 || TREE_CHAIN (field)))))
6192 if (value == error_mark_node)
6194 constructor_erroneous = 1;
6198 /* If this element doesn't come next in sequence,
6199 put it on constructor_pending_elts. */
6200 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6201 && (!constructor_incremental
6202 || !tree_int_cst_equal (field, constructor_unfilled_index)))
6204 if (constructor_incremental
6205 && tree_int_cst_lt (field, constructor_unfilled_index))
6206 set_nonincremental_init ();
6208 add_pending_init (field,
6209 digest_init (type, value, require_constant_value,
6210 require_constant_elements));
6213 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6214 && (!constructor_incremental
6215 || field != constructor_unfilled_fields))
6217 /* We do this for records but not for unions. In a union,
6218 no matter which field is specified, it can be initialized
6219 right away since it starts at the beginning of the union. */
6220 if (constructor_incremental)
6222 if (!constructor_unfilled_fields)
6223 set_nonincremental_init ();
6226 tree bitpos, unfillpos;
6228 bitpos = bit_position (field);
6229 unfillpos = bit_position (constructor_unfilled_fields);
6231 if (tree_int_cst_lt (bitpos, unfillpos))
6232 set_nonincremental_init ();
6236 add_pending_init (field,
6237 digest_init (type, value, require_constant_value,
6238 require_constant_elements));
6241 else if (TREE_CODE (constructor_type) == UNION_TYPE
6242 && constructor_elements)
6244 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6245 warning_init ("initialized field with side-effects overwritten");
6247 /* We can have just one union field set. */
6248 constructor_elements = 0;
6251 /* Otherwise, output this element either to
6252 constructor_elements or to the assembler file. */
6254 if (field && TREE_CODE (field) == INTEGER_CST)
6255 field = copy_node (field);
6256 constructor_elements
6257 = tree_cons (field, digest_init (type, value,
6258 require_constant_value,
6259 require_constant_elements),
6260 constructor_elements);
6262 /* Advance the variable that indicates sequential elements output. */
6263 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6264 constructor_unfilled_index
6265 = size_binop (PLUS_EXPR, constructor_unfilled_index,
6267 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6269 constructor_unfilled_fields
6270 = TREE_CHAIN (constructor_unfilled_fields);
6272 /* Skip any nameless bit fields. */
6273 while (constructor_unfilled_fields != 0
6274 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6275 && DECL_NAME (constructor_unfilled_fields) == 0)
6276 constructor_unfilled_fields =
6277 TREE_CHAIN (constructor_unfilled_fields);
6279 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6280 constructor_unfilled_fields = 0;
6282 /* Now output any pending elements which have become next. */
6284 output_pending_init_elements (0);
6287 /* Output any pending elements which have become next.
6288 As we output elements, constructor_unfilled_{fields,index}
6289 advances, which may cause other elements to become next;
6290 if so, they too are output.
6292 If ALL is 0, we return when there are
6293 no more pending elements to output now.
6295 If ALL is 1, we output space as necessary so that
6296 we can output all the pending elements. */
6299 output_pending_init_elements (all)
6302 struct init_node *elt = constructor_pending_elts;
6307 /* Look thru the whole pending tree.
6308 If we find an element that should be output now,
6309 output it. Otherwise, set NEXT to the element
6310 that comes first among those still pending. */
6315 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6317 if (tree_int_cst_equal (elt->purpose,
6318 constructor_unfilled_index))
6319 output_init_element (elt->value,
6320 TREE_TYPE (constructor_type),
6321 constructor_unfilled_index, 0);
6322 else if (tree_int_cst_lt (constructor_unfilled_index,
6325 /* Advance to the next smaller node. */
6330 /* We have reached the smallest node bigger than the
6331 current unfilled index. Fill the space first. */
6332 next = elt->purpose;
6338 /* Advance to the next bigger node. */
6343 /* We have reached the biggest node in a subtree. Find
6344 the parent of it, which is the next bigger node. */
6345 while (elt->parent && elt->parent->right == elt)
6348 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6351 next = elt->purpose;
6357 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6358 || TREE_CODE (constructor_type) == UNION_TYPE)
6360 tree ctor_unfilled_bitpos, elt_bitpos;
6362 /* If the current record is complete we are done. */
6363 if (constructor_unfilled_fields == 0)
6366 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6367 elt_bitpos = bit_position (elt->purpose);
6368 /* We can't compare fields here because there might be empty
6369 fields in between. */
6370 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6372 constructor_unfilled_fields = elt->purpose;
6373 output_init_element (elt->value, TREE_TYPE (elt->purpose),
6376 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6378 /* Advance to the next smaller node. */
6383 /* We have reached the smallest node bigger than the
6384 current unfilled field. Fill the space first. */
6385 next = elt->purpose;
6391 /* Advance to the next bigger node. */
6396 /* We have reached the biggest node in a subtree. Find
6397 the parent of it, which is the next bigger node. */
6398 while (elt->parent && elt->parent->right == elt)
6402 && (tree_int_cst_lt (ctor_unfilled_bitpos,
6403 bit_position (elt->purpose))))
6405 next = elt->purpose;
6413 /* Ordinarily return, but not if we want to output all
6414 and there are elements left. */
6415 if (! (all && next != 0))
6418 /* If it's not incremental, just skip over the gap, so that after
6419 jumping to retry we will output the next successive element. */
6420 if (TREE_CODE (constructor_type) == RECORD_TYPE
6421 || TREE_CODE (constructor_type) == UNION_TYPE)
6422 constructor_unfilled_fields = next;
6423 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6424 constructor_unfilled_index = next;
6426 /* ELT now points to the node in the pending tree with the next
6427 initializer to output. */
6431 /* Add one non-braced element to the current constructor level.
6432 This adjusts the current position within the constructor's type.
6433 This may also start or terminate implicit levels
6434 to handle a partly-braced initializer.
6436 Once this has found the correct level for the new element,
6437 it calls output_init_element. */
6440 process_init_element (value)
6443 tree orig_value = value;
6444 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6446 designator_depth = 0;
6447 designator_errorneous = 0;
6449 /* Handle superfluous braces around string cst as in
6450 char x[] = {"foo"}; */
6453 && TREE_CODE (constructor_type) == ARRAY_TYPE
6454 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6455 && integer_zerop (constructor_unfilled_index))
6457 if (constructor_stack->replacement_value)
6458 error_init ("excess elements in char array initializer");
6459 constructor_stack->replacement_value = value;
6463 if (constructor_stack->replacement_value != 0)
6465 error_init ("excess elements in struct initializer");
6469 /* Ignore elements of a brace group if it is entirely superfluous
6470 and has already been diagnosed. */
6471 if (constructor_type == 0)
6474 /* If we've exhausted any levels that didn't have braces,
6476 while (constructor_stack->implicit)
6478 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6479 || TREE_CODE (constructor_type) == UNION_TYPE)
6480 && constructor_fields == 0)
6481 process_init_element (pop_init_level (1));
6482 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6483 && (constructor_max_index == 0
6484 || tree_int_cst_lt (constructor_max_index,
6485 constructor_index)))
6486 process_init_element (pop_init_level (1));
6491 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6492 if (constructor_range_stack)
6493 value = save_expr (value);
6497 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6500 enum tree_code fieldcode;
6502 if (constructor_fields == 0)
6504 pedwarn_init ("excess elements in struct initializer");
6508 fieldtype = TREE_TYPE (constructor_fields);
6509 if (fieldtype != error_mark_node)
6510 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6511 fieldcode = TREE_CODE (fieldtype);
6513 /* Accept a string constant to initialize a subarray. */
6515 && fieldcode == ARRAY_TYPE
6516 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6519 /* Otherwise, if we have come to a subaggregate,
6520 and we don't have an element of its type, push into it. */
6521 else if (value != 0 && !constructor_no_implicit
6522 && value != error_mark_node
6523 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6524 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6525 || fieldcode == UNION_TYPE))
6527 push_init_level (1);
6533 push_member_name (constructor_fields);
6534 output_init_element (value, fieldtype, constructor_fields, 1);
6535 RESTORE_SPELLING_DEPTH (constructor_depth);
6538 /* Do the bookkeeping for an element that was
6539 directly output as a constructor. */
6541 /* For a record, keep track of end position of last field. */
6542 if (DECL_SIZE (constructor_fields))
6543 constructor_bit_index
6544 = size_binop (PLUS_EXPR,
6545 bit_position (constructor_fields),
6546 DECL_SIZE (constructor_fields));
6548 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6549 /* Skip any nameless bit fields. */
6550 while (constructor_unfilled_fields != 0
6551 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6552 && DECL_NAME (constructor_unfilled_fields) == 0)
6553 constructor_unfilled_fields =
6554 TREE_CHAIN (constructor_unfilled_fields);
6557 constructor_fields = TREE_CHAIN (constructor_fields);
6558 /* Skip any nameless bit fields at the beginning. */
6559 while (constructor_fields != 0
6560 && DECL_C_BIT_FIELD (constructor_fields)
6561 && DECL_NAME (constructor_fields) == 0)
6562 constructor_fields = TREE_CHAIN (constructor_fields);
6564 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6567 enum tree_code fieldcode;
6569 if (constructor_fields == 0)
6571 pedwarn_init ("excess elements in union initializer");
6575 fieldtype = TREE_TYPE (constructor_fields);
6576 if (fieldtype != error_mark_node)
6577 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6578 fieldcode = TREE_CODE (fieldtype);
6580 /* Warn that traditional C rejects initialization of unions.
6581 We skip the warning if the value is zero. This is done
6582 under the assumption that the zero initializer in user
6583 code appears conditioned on e.g. __STDC__ to avoid
6584 "missing initializer" warnings and relies on default
6585 initialization to zero in the traditional C case. */
6586 if (warn_traditional && !in_system_header
6587 && !(value && (integer_zerop (value) || real_zerop (value))))
6588 warning ("traditional C rejects initialization of unions");
6590 /* Accept a string constant to initialize a subarray. */
6592 && fieldcode == ARRAY_TYPE
6593 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6596 /* Otherwise, if we have come to a subaggregate,
6597 and we don't have an element of its type, push into it. */
6598 else if (value != 0 && !constructor_no_implicit
6599 && value != error_mark_node
6600 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6601 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6602 || fieldcode == UNION_TYPE))
6604 push_init_level (1);
6610 push_member_name (constructor_fields);
6611 output_init_element (value, fieldtype, constructor_fields, 1);
6612 RESTORE_SPELLING_DEPTH (constructor_depth);
6615 /* Do the bookkeeping for an element that was
6616 directly output as a constructor. */
6618 constructor_bit_index = DECL_SIZE (constructor_fields);
6619 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6622 constructor_fields = 0;
6624 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6626 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6627 enum tree_code eltcode = TREE_CODE (elttype);
6629 /* Accept a string constant to initialize a subarray. */
6631 && eltcode == ARRAY_TYPE
6632 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6635 /* Otherwise, if we have come to a subaggregate,
6636 and we don't have an element of its type, push into it. */
6637 else if (value != 0 && !constructor_no_implicit
6638 && value != error_mark_node
6639 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6640 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6641 || eltcode == UNION_TYPE))
6643 push_init_level (1);
6647 if (constructor_max_index != 0
6648 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6649 || integer_all_onesp (constructor_max_index)))
6651 pedwarn_init ("excess elements in array initializer");
6655 /* Now output the actual element. */
6658 push_array_bounds (tree_low_cst (constructor_index, 0));
6659 output_init_element (value, elttype, constructor_index, 1);
6660 RESTORE_SPELLING_DEPTH (constructor_depth);
6664 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6667 /* If we are doing the bookkeeping for an element that was
6668 directly output as a constructor, we must update
6669 constructor_unfilled_index. */
6670 constructor_unfilled_index = constructor_index;
6673 /* Handle the sole element allowed in a braced initializer
6674 for a scalar variable. */
6675 else if (constructor_fields == 0)
6677 pedwarn_init ("excess elements in scalar initializer");
6683 output_init_element (value, constructor_type, NULL_TREE, 1);
6684 constructor_fields = 0;
6687 /* Handle range initializers either at this level or anywhere higher
6688 in the designator stack. */
6689 if (constructor_range_stack)
6691 struct constructor_range_stack *p, *range_stack;
6694 range_stack = constructor_range_stack;
6695 constructor_range_stack = 0;
6696 while (constructor_stack != range_stack->stack)
6698 if (!constructor_stack->implicit)
6700 process_init_element (pop_init_level (1));
6702 for (p = range_stack;
6703 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6706 if (!constructor_stack->implicit)
6708 process_init_element (pop_init_level (1));
6711 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6712 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6717 constructor_index = p->index;
6718 constructor_fields = p->fields;
6719 if (finish && p->range_end && p->index == p->range_start)
6727 push_init_level (2);
6728 p->stack = constructor_stack;
6729 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6730 p->index = p->range_start;
6734 constructor_range_stack = range_stack;
6741 constructor_range_stack = 0;
6744 /* Build a simple asm-statement, from one string literal. */
6746 simple_asm_stmt (expr)
6751 if (TREE_CODE (expr) == ADDR_EXPR)
6752 expr = TREE_OPERAND (expr, 0);
6754 if (TREE_CODE (expr) == STRING_CST)
6758 if (TREE_CHAIN (expr))
6759 expr = combine_strings (expr);
6760 stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6761 NULL_TREE, NULL_TREE,
6763 ASM_INPUT_P (stmt) = 1;
6767 error ("argument of `asm' is not a constant string");
6771 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6772 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6775 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6784 if (TREE_CHAIN (string))
6785 string = combine_strings (string);
6786 if (TREE_CODE (string) != STRING_CST)
6788 error ("asm template is not a string constant");
6792 if (cv_qualifier != NULL_TREE
6793 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6795 warning ("%s qualifier ignored on asm",
6796 IDENTIFIER_POINTER (cv_qualifier));
6797 cv_qualifier = NULL_TREE;
6800 /* We can remove output conversions that change the type,
6801 but not the mode. */
6802 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6804 tree output = TREE_VALUE (tail);
6806 STRIP_NOPS (output);
6807 TREE_VALUE (tail) = output;
6809 /* Allow conversions as LHS here. build_modify_expr as called below
6810 will do the right thing with them. */
6811 while (TREE_CODE (output) == NOP_EXPR
6812 || TREE_CODE (output) == CONVERT_EXPR
6813 || TREE_CODE (output) == FLOAT_EXPR
6814 || TREE_CODE (output) == FIX_TRUNC_EXPR
6815 || TREE_CODE (output) == FIX_FLOOR_EXPR
6816 || TREE_CODE (output) == FIX_ROUND_EXPR
6817 || TREE_CODE (output) == FIX_CEIL_EXPR)
6818 output = TREE_OPERAND (output, 0);
6820 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6823 /* Remove output conversions that change the type but not the mode. */
6824 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6826 tree output = TREE_VALUE (tail);
6827 STRIP_NOPS (output);
6828 TREE_VALUE (tail) = output;
6831 /* Perform default conversions on array and function inputs.
6832 Don't do this for other types as it would screw up operands
6833 expected to be in memory. */
6834 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6835 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6836 || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6837 TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6839 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6840 outputs, inputs, clobbers));
6843 /* Expand an ASM statement with operands, handling output operands
6844 that are not variables or INDIRECT_REFS by transforming such
6845 cases into cases that expand_asm_operands can handle.
6847 Arguments are same as for expand_asm_operands. */
6850 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6851 tree string, outputs, inputs, clobbers;
6853 const char *filename;
6856 int noutputs = list_length (outputs);
6858 /* o[I] is the place that output number I should be written. */
6859 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6862 /* Record the contents of OUTPUTS before it is modified. */
6863 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6864 o[i] = TREE_VALUE (tail);
6866 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6867 OUTPUTS some trees for where the values were actually stored. */
6868 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6870 /* Copy all the intermediate outputs into the specified outputs. */
6871 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6873 if (o[i] != TREE_VALUE (tail))
6875 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6876 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6879 /* Restore the original value so that it's correct the next
6880 time we expand this function. */
6881 TREE_VALUE (tail) = o[i];
6883 /* Detect modification of read-only values.
6884 (Otherwise done by build_modify_expr.) */
6887 tree type = TREE_TYPE (o[i]);
6888 if (TREE_READONLY (o[i])
6889 || TYPE_READONLY (type)
6890 || ((TREE_CODE (type) == RECORD_TYPE
6891 || TREE_CODE (type) == UNION_TYPE)
6892 && C_TYPE_FIELDS_READONLY (type)))
6893 readonly_warning (o[i], "modification by `asm'");
6897 /* Those MODIFY_EXPRs could do autoincrements. */
6901 /* Expand a C `return' statement.
6902 RETVAL is the expression for what to return,
6903 or a null pointer for `return;' with no value. */
6906 c_expand_return (retval)
6909 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6911 if (TREE_THIS_VOLATILE (current_function_decl))
6912 warning ("function declared `noreturn' has a `return' statement");
6916 current_function_returns_null = 1;
6917 if ((warn_return_type || flag_isoc99)
6918 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6919 pedwarn_c99 ("`return' with no value, in function returning non-void");
6921 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6923 current_function_returns_null = 1;
6924 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6925 pedwarn ("`return' with a value, in function returning void");
6929 tree t = convert_for_assignment (valtype, retval, _("return"),
6930 NULL_TREE, NULL_TREE, 0);
6931 tree res = DECL_RESULT (current_function_decl);
6934 if (t == error_mark_node)
6937 inner = t = convert (TREE_TYPE (res), t);
6939 /* Strip any conversions, additions, and subtractions, and see if
6940 we are returning the address of a local variable. Warn if so. */
6943 switch (TREE_CODE (inner))
6945 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6947 inner = TREE_OPERAND (inner, 0);
6951 /* If the second operand of the MINUS_EXPR has a pointer
6952 type (or is converted from it), this may be valid, so
6953 don't give a warning. */
6955 tree op1 = TREE_OPERAND (inner, 1);
6957 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6958 && (TREE_CODE (op1) == NOP_EXPR
6959 || TREE_CODE (op1) == NON_LVALUE_EXPR
6960 || TREE_CODE (op1) == CONVERT_EXPR))
6961 op1 = TREE_OPERAND (op1, 0);
6963 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6966 inner = TREE_OPERAND (inner, 0);
6971 inner = TREE_OPERAND (inner, 0);
6973 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6974 inner = TREE_OPERAND (inner, 0);
6976 if (TREE_CODE (inner) == VAR_DECL
6977 && ! DECL_EXTERNAL (inner)
6978 && ! TREE_STATIC (inner)
6979 && DECL_CONTEXT (inner) == current_function_decl)
6980 warning ("function returns address of local variable");
6990 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6991 current_function_returns_value = 1;
6994 return add_stmt (build_return_stmt (retval));
6998 /* The SWITCH_STMT being built. */
7000 /* A splay-tree mapping the low element of a case range to the high
7001 element, or NULL_TREE if there is no high element. Used to
7002 determine whether or not a new case label duplicates an old case
7003 label. We need a tree, rather than simply a hash table, because
7004 of the GNU case range extension. */
7006 /* The next node on the stack. */
7007 struct c_switch *next;
7010 /* A stack of the currently active switch statements. The innermost
7011 switch statement is on the top of the stack. There is no need to
7012 mark the stack for garbage collection because it is only active
7013 during the processing of the body of a function, and we never
7014 collect at that point. */
7016 static struct c_switch *switch_stack;
7018 /* Start a C switch statement, testing expression EXP. Return the new
7025 register enum tree_code code;
7027 struct c_switch *cs;
7029 if (exp != error_mark_node)
7031 code = TREE_CODE (TREE_TYPE (exp));
7032 type = TREE_TYPE (exp);
7034 if (! INTEGRAL_TYPE_P (type)
7035 && code != ERROR_MARK)
7037 error ("switch quantity not an integer");
7038 exp = integer_zero_node;
7043 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7045 if (warn_traditional && !in_system_header
7046 && (type == long_integer_type_node
7047 || type == long_unsigned_type_node))
7048 warning ("`long' switch expression not converted to `int' in ISO C");
7050 exp = default_conversion (exp);
7051 type = TREE_TYPE (exp);
7052 index = get_unwidened (exp, NULL_TREE);
7053 /* We can't strip a conversion from a signed type to an
7054 unsigned, because if we did, int_fits_type_p would do the
7055 wrong thing when checking case values for being in range,
7056 and it's too hard to do the right thing. */
7057 if (TREE_UNSIGNED (TREE_TYPE (exp))
7058 == TREE_UNSIGNED (TREE_TYPE (index)))
7063 /* Add this new SWITCH_STMT to the stack. */
7064 cs = (struct c_switch *) xmalloc (sizeof (*cs));
7065 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7066 cs->cases = splay_tree_new (case_compare, NULL, NULL);
7067 cs->next = switch_stack;
7070 return add_stmt (switch_stack->switch_stmt);
7073 /* Process a case label. */
7076 do_case (low_value, high_value)
7080 tree label = NULL_TREE;
7084 label = c_add_case_label (switch_stack->cases,
7085 SWITCH_COND (switch_stack->switch_stmt),
7086 low_value, high_value);
7087 if (label == error_mark_node)
7091 error ("case label not within a switch statement");
7093 error ("`default' label not within a switch statement");
7098 /* Finish the switch statement. */
7103 struct c_switch *cs = switch_stack;
7105 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7107 /* Pop the stack. */
7108 switch_stack = switch_stack->next;
7109 splay_tree_delete (cs->cases);