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 default_function_array_conversion PARAMS ((tree));
59 static tree lookup_field PARAMS ((tree, tree));
60 static tree convert_arguments PARAMS ((tree, tree, tree, tree));
61 static tree pointer_int_sum PARAMS ((enum tree_code, tree, tree));
62 static tree pointer_diff PARAMS ((tree, tree));
63 static tree unary_complex_lvalue PARAMS ((enum tree_code, tree, int));
64 static void pedantic_lvalue_warning PARAMS ((enum tree_code));
65 static tree internal_build_compound_expr PARAMS ((tree, int));
66 static tree convert_for_assignment PARAMS ((tree, tree, const char *,
68 static void warn_for_assignment PARAMS ((const char *, const char *,
70 static tree valid_compound_expr_initializer PARAMS ((tree, tree));
71 static void push_string PARAMS ((const char *));
72 static void push_member_name PARAMS ((tree));
73 static void push_array_bounds PARAMS ((int));
74 static int spelling_length PARAMS ((void));
75 static char *print_spelling PARAMS ((char *));
76 static void warning_init PARAMS ((const char *));
77 static tree digest_init PARAMS ((tree, tree, int, int));
78 static void output_init_element PARAMS ((tree, tree, tree, int));
79 static void output_pending_init_elements PARAMS ((int));
80 static int set_designator PARAMS ((int));
81 static void push_range_stack PARAMS ((tree));
82 static void add_pending_init PARAMS ((tree, tree));
83 static void set_nonincremental_init PARAMS ((void));
84 static void set_nonincremental_init_from_string PARAMS ((tree));
85 static tree find_init_member PARAMS ((tree));
87 /* Do `exp = require_complete_type (exp);' to make sure exp
88 does not have an incomplete type. (That includes void types.) */
91 require_complete_type (value)
94 tree type = TREE_TYPE (value);
96 if (TREE_CODE (value) == ERROR_MARK)
97 return error_mark_node;
99 /* First, detect a valid value with a complete type. */
100 if (COMPLETE_TYPE_P (type))
103 incomplete_type_error (value, type);
104 return error_mark_node;
107 /* Print an error message for invalid use of an incomplete type.
108 VALUE is the expression that was used (or 0 if that isn't known)
109 and TYPE is the type that was invalid. */
112 incomplete_type_error (value, type)
116 const char *type_code_string;
118 /* Avoid duplicate error message. */
119 if (TREE_CODE (type) == ERROR_MARK)
122 if (value != 0 && (TREE_CODE (value) == VAR_DECL
123 || TREE_CODE (value) == PARM_DECL))
124 error ("`%s' has an incomplete type",
125 IDENTIFIER_POINTER (DECL_NAME (value)));
129 /* We must print an error message. Be clever about what it says. */
131 switch (TREE_CODE (type))
134 type_code_string = "struct";
138 type_code_string = "union";
142 type_code_string = "enum";
146 error ("invalid use of void expression");
150 if (TYPE_DOMAIN (type))
152 type = TREE_TYPE (type);
155 error ("invalid use of array with unspecified bounds");
162 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
163 error ("invalid use of undefined type `%s %s'",
164 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
166 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
167 error ("invalid use of incomplete typedef `%s'",
168 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
172 /* Return a variant of TYPE which has all the type qualifiers of LIKE
173 as well as those of TYPE. */
176 qualify_type (type, like)
179 return c_build_qualified_type (type,
180 TYPE_QUALS (type) | TYPE_QUALS (like));
183 /* Return the common type of two types.
184 We assume that comptypes has already been done and returned 1;
185 if that isn't so, this may crash. In particular, we assume that qualifiers
188 This is the type for the result of most arithmetic operations
189 if the operands have the given two types. */
195 enum tree_code code1;
196 enum tree_code code2;
199 /* Save time if the two types are the same. */
201 if (t1 == t2) return t1;
203 /* If one type is nonsense, use the other. */
204 if (t1 == error_mark_node)
206 if (t2 == error_mark_node)
209 /* Merge the attributes. */
210 attributes = (*targetm.merge_type_attributes) (t1, t2);
212 /* Treat an enum type as the unsigned integer type of the same width. */
214 if (TREE_CODE (t1) == ENUMERAL_TYPE)
215 t1 = type_for_size (TYPE_PRECISION (t1), 1);
216 if (TREE_CODE (t2) == ENUMERAL_TYPE)
217 t2 = type_for_size (TYPE_PRECISION (t2), 1);
219 code1 = TREE_CODE (t1);
220 code2 = TREE_CODE (t2);
222 /* If one type is complex, form the common type of the non-complex
223 components, then make that complex. Use T1 or T2 if it is the
225 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
227 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
228 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
229 tree subtype = common_type (subtype1, subtype2);
231 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
232 return build_type_attribute_variant (t1, attributes);
233 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
234 return build_type_attribute_variant (t2, attributes);
236 return build_type_attribute_variant (build_complex_type (subtype),
244 /* If only one is real, use it as the result. */
246 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
247 return build_type_attribute_variant (t1, attributes);
249 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
250 return build_type_attribute_variant (t2, attributes);
252 /* Both real or both integers; use the one with greater precision. */
254 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
255 return build_type_attribute_variant (t1, attributes);
256 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
257 return build_type_attribute_variant (t2, attributes);
259 /* Same precision. Prefer longs to ints even when same size. */
261 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
262 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
263 return build_type_attribute_variant (long_unsigned_type_node,
266 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
267 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
269 /* But preserve unsignedness from the other type,
270 since long cannot hold all the values of an unsigned int. */
271 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
272 t1 = long_unsigned_type_node;
274 t1 = long_integer_type_node;
275 return build_type_attribute_variant (t1, attributes);
278 /* Likewise, prefer long double to double even if same size. */
279 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
280 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
281 return build_type_attribute_variant (long_double_type_node,
284 /* Otherwise prefer the unsigned one. */
286 if (TREE_UNSIGNED (t1))
287 return build_type_attribute_variant (t1, attributes);
289 return build_type_attribute_variant (t2, attributes);
292 /* For two pointers, do this recursively on the target type,
293 and combine the qualifiers of the two types' targets. */
294 /* This code was turned off; I don't know why.
295 But ANSI C specifies doing this with the qualifiers.
296 So I turned it on again. */
298 tree pointed_to_1 = TREE_TYPE (t1);
299 tree pointed_to_2 = TREE_TYPE (t2);
300 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
301 TYPE_MAIN_VARIANT (pointed_to_2));
302 t1 = build_pointer_type (c_build_qualified_type
304 TYPE_QUALS (pointed_to_1) |
305 TYPE_QUALS (pointed_to_2)));
306 return build_type_attribute_variant (t1, attributes);
309 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
310 return build_type_attribute_variant (t1, attributes);
315 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
316 /* Save space: see if the result is identical to one of the args. */
317 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
318 return build_type_attribute_variant (t1, attributes);
319 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
320 return build_type_attribute_variant (t2, attributes);
321 /* Merge the element types, and have a size if either arg has one. */
322 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
323 return build_type_attribute_variant (t1, attributes);
327 /* Function types: prefer the one that specified arg types.
328 If both do, merge the arg types. Also merge the return types. */
330 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
331 tree p1 = TYPE_ARG_TYPES (t1);
332 tree p2 = TYPE_ARG_TYPES (t2);
337 /* Save space: see if the result is identical to one of the args. */
338 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
339 return build_type_attribute_variant (t1, attributes);
340 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
341 return build_type_attribute_variant (t2, attributes);
343 /* Simple way if one arg fails to specify argument types. */
344 if (TYPE_ARG_TYPES (t1) == 0)
346 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
347 return build_type_attribute_variant (t1, attributes);
349 if (TYPE_ARG_TYPES (t2) == 0)
351 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
352 return build_type_attribute_variant (t1, attributes);
355 /* If both args specify argument types, we must merge the two
356 lists, argument by argument. */
359 declare_parm_level (1);
361 len = list_length (p1);
364 for (i = 0; i < len; i++)
365 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
370 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
372 /* A null type means arg type is not specified.
373 Take whatever the other function type has. */
374 if (TREE_VALUE (p1) == 0)
376 TREE_VALUE (n) = TREE_VALUE (p2);
379 if (TREE_VALUE (p2) == 0)
381 TREE_VALUE (n) = TREE_VALUE (p1);
385 /* Given wait (union {union wait *u; int *i} *)
386 and wait (union wait *),
387 prefer union wait * as type of parm. */
388 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
389 && TREE_VALUE (p1) != TREE_VALUE (p2))
392 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
393 memb; memb = TREE_CHAIN (memb))
394 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
396 TREE_VALUE (n) = TREE_VALUE (p2);
398 pedwarn ("function types not truly compatible in ISO C");
402 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
403 && TREE_VALUE (p2) != TREE_VALUE (p1))
406 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
407 memb; memb = TREE_CHAIN (memb))
408 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
410 TREE_VALUE (n) = TREE_VALUE (p1);
412 pedwarn ("function types not truly compatible in ISO C");
416 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
422 t1 = build_function_type (valtype, newargs);
423 /* ... falls through ... */
427 return build_type_attribute_variant (t1, attributes);
432 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
433 or various other operations. Return 2 if they are compatible
434 but a warning may be needed if you use them together. */
437 comptypes (type1, type2)
444 /* Suppress errors caused by previously reported errors. */
446 if (t1 == t2 || !t1 || !t2
447 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
450 /* If either type is the internal version of sizetype, return the
452 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
453 && TYPE_DOMAIN (t1) != 0)
454 t1 = TYPE_DOMAIN (t1);
456 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
457 && TYPE_DOMAIN (t2) != 0)
458 t2 = TYPE_DOMAIN (t2);
460 /* Treat an enum type as the integer type of the same width and
463 if (TREE_CODE (t1) == ENUMERAL_TYPE)
464 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
465 if (TREE_CODE (t2) == ENUMERAL_TYPE)
466 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
471 /* Different classes of types can't be compatible. */
473 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
475 /* Qualifiers must match. */
477 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
480 /* Allow for two different type nodes which have essentially the same
481 definition. Note that we already checked for equality of the type
482 qualifiers (just above). */
484 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
487 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
488 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
491 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
494 switch (TREE_CODE (t1))
497 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
498 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
502 val = function_types_compatible_p (t1, t2);
507 tree d1 = TYPE_DOMAIN (t1);
508 tree d2 = TYPE_DOMAIN (t2);
509 bool d1_variable, d2_variable;
510 bool d1_zero, d2_zero;
513 /* Target types must match incl. qualifiers. */
514 if (TREE_TYPE (t1) != TREE_TYPE (t2)
515 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
518 /* Sizes must match unless one is missing or variable. */
519 if (d1 == 0 || d2 == 0 || d1 == d2)
522 d1_zero = ! TYPE_MAX_VALUE (d1);
523 d2_zero = ! TYPE_MAX_VALUE (d2);
525 d1_variable = (! d1_zero
526 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
527 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
528 d2_variable = (! d2_zero
529 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
530 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
532 if (d1_variable || d2_variable)
534 if (d1_zero && d2_zero)
536 if (d1_zero || d2_zero
537 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
538 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
545 if (maybe_objc_comptypes (t1, t2, 0) == 1)
552 return attrval == 2 && val == 1 ? 2 : val;
555 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
556 ignoring their qualifiers. */
559 comp_target_types (ttl, ttr)
564 /* Give maybe_objc_comptypes a crack at letting these types through. */
565 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
568 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
569 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
571 if (val == 2 && pedantic)
572 pedwarn ("types are not quite compatible");
576 /* Subroutines of `comptypes'. */
578 /* Return 1 if two function types F1 and F2 are compatible.
579 If either type specifies no argument types,
580 the other must specify a fixed number of self-promoting arg types.
581 Otherwise, if one type specifies only the number of arguments,
582 the other must specify that number of self-promoting arg types.
583 Otherwise, the argument types must match. */
586 function_types_compatible_p (f1, f2)
590 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
594 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
595 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
598 args1 = TYPE_ARG_TYPES (f1);
599 args2 = TYPE_ARG_TYPES (f2);
601 /* An unspecified parmlist matches any specified parmlist
602 whose argument types don't need default promotions. */
606 if (!self_promoting_args_p (args2))
608 /* If one of these types comes from a non-prototype fn definition,
609 compare that with the other type's arglist.
610 If they don't match, ask for a warning (but no error). */
611 if (TYPE_ACTUAL_ARG_TYPES (f1)
612 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
618 if (!self_promoting_args_p (args1))
620 if (TYPE_ACTUAL_ARG_TYPES (f2)
621 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
626 /* Both types have argument lists: compare them and propagate results. */
627 val1 = type_lists_compatible_p (args1, args2);
628 return val1 != 1 ? val1 : val;
631 /* Check two lists of types for compatibility,
632 returning 0 for incompatible, 1 for compatible,
633 or 2 for compatible with warning. */
636 type_lists_compatible_p (args1, args2)
639 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
645 if (args1 == 0 && args2 == 0)
647 /* If one list is shorter than the other,
648 they fail to match. */
649 if (args1 == 0 || args2 == 0)
651 /* A null pointer instead of a type
652 means there is supposed to be an argument
653 but nothing is specified about what type it has.
654 So match anything that self-promotes. */
655 if (TREE_VALUE (args1) == 0)
657 if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE)
660 else if (TREE_VALUE (args2) == 0)
662 if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE)
665 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
666 TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
668 /* Allow wait (union {union wait *u; int *i} *)
669 and wait (union wait *) to be compatible. */
670 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
671 && (TYPE_NAME (TREE_VALUE (args1)) == 0
672 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
673 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
674 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
675 TYPE_SIZE (TREE_VALUE (args2))))
678 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
679 memb; memb = TREE_CHAIN (memb))
680 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
685 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
686 && (TYPE_NAME (TREE_VALUE (args2)) == 0
687 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
688 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
689 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
690 TYPE_SIZE (TREE_VALUE (args1))))
693 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
694 memb; memb = TREE_CHAIN (memb))
695 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
704 /* comptypes said ok, but record if it said to warn. */
708 args1 = TREE_CHAIN (args1);
709 args2 = TREE_CHAIN (args2);
713 /* Compute the value of the `sizeof' operator. */
719 enum tree_code code = TREE_CODE (type);
722 if (code == FUNCTION_TYPE)
724 if (pedantic || warn_pointer_arith)
725 pedwarn ("sizeof applied to a function type");
726 size = size_one_node;
728 else if (code == VOID_TYPE)
730 if (pedantic || warn_pointer_arith)
731 pedwarn ("sizeof applied to a void type");
732 size = size_one_node;
734 else if (code == ERROR_MARK)
735 size = size_one_node;
736 else if (!COMPLETE_TYPE_P (type))
738 error ("sizeof applied to an incomplete type");
739 size = size_zero_node;
742 /* Convert in case a char is more than one unit. */
743 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
744 size_int (TYPE_PRECISION (char_type_node)
747 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
748 TYPE_IS_SIZETYPE means that certain things (like overflow) will
749 never happen. However, this node should really have type
750 `size_t', which is just a typedef for an ordinary integer type. */
751 return fold (build1 (NOP_EXPR, c_size_type_node, size));
755 c_sizeof_nowarn (type)
758 enum tree_code code = TREE_CODE (type);
761 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
762 size = size_one_node;
763 else if (!COMPLETE_TYPE_P (type))
764 size = size_zero_node;
766 /* Convert in case a char is more than one unit. */
767 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
768 size_int (TYPE_PRECISION (char_type_node)
771 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
772 TYPE_IS_SIZETYPE means that certain things (like overflow) will
773 never happen. However, this node should really have type
774 `size_t', which is just a typedef for an ordinary integer type. */
775 return fold (build1 (NOP_EXPR, c_size_type_node, size));
778 /* Compute the size to increment a pointer by. */
781 c_size_in_bytes (type)
784 enum tree_code code = TREE_CODE (type);
786 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
787 return size_one_node;
789 if (!COMPLETE_OR_VOID_TYPE_P (type))
791 error ("arithmetic on pointer to an incomplete type");
792 return size_one_node;
795 /* Convert in case a char is more than one unit. */
796 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
797 size_int (TYPE_PRECISION (char_type_node)
801 /* Return either DECL or its known constant value (if it has one). */
804 decl_constant_value (decl)
807 if (/* Don't change a variable array bound or initial value to a constant
808 in a place where a variable is invalid. */
809 current_function_decl != 0
810 && ! TREE_THIS_VOLATILE (decl)
811 && TREE_READONLY (decl)
812 && DECL_INITIAL (decl) != 0
813 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
814 /* This is invalid if initial value is not constant.
815 If it has either a function call, a memory reference,
816 or a variable, then re-evaluating it could give different results. */
817 && TREE_CONSTANT (DECL_INITIAL (decl))
818 /* Check for cases where this is sub-optimal, even though valid. */
819 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
820 return DECL_INITIAL (decl);
824 /* Return either DECL or its known constant value (if it has one), but
825 return DECL if pedantic or DECL has mode BLKmode. This is for
826 bug-compatibility with the old behavior of decl_constant_value
827 (before GCC 3.0); every use of this function is a bug and it should
828 be removed before GCC 3.1. It is not appropriate to use pedantic
829 in a way that affects optimization, and BLKmode is probably not the
830 right test for avoiding misoptimizations either. */
833 decl_constant_value_for_broken_optimization (decl)
836 if (pedantic || DECL_MODE (decl) == BLKmode)
839 return decl_constant_value (decl);
843 /* Perform the default conversion of arrays and functions to pointers.
844 Return the result of converting EXP. For any other expression, just
848 default_function_array_conversion (exp)
852 tree type = TREE_TYPE (exp);
853 enum tree_code code = TREE_CODE (type);
856 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
859 Do not use STRIP_NOPS here! It will remove conversions from pointer
860 to integer and cause infinite recursion. */
862 while (TREE_CODE (exp) == NON_LVALUE_EXPR
863 || (TREE_CODE (exp) == NOP_EXPR
864 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
866 if (TREE_CODE (exp) == NON_LVALUE_EXPR)
868 exp = TREE_OPERAND (exp, 0);
871 /* Preserve the original expression code. */
872 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
873 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
875 if (code == FUNCTION_TYPE)
877 return build_unary_op (ADDR_EXPR, exp, 0);
879 if (code == ARRAY_TYPE)
882 tree restype = TREE_TYPE (type);
888 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
890 constp = TREE_READONLY (exp);
891 volatilep = TREE_THIS_VOLATILE (exp);
894 if (TYPE_QUALS (type) || constp || volatilep)
896 = c_build_qualified_type (restype,
898 | (constp * TYPE_QUAL_CONST)
899 | (volatilep * TYPE_QUAL_VOLATILE));
901 if (TREE_CODE (exp) == INDIRECT_REF)
902 return convert (TYPE_POINTER_TO (restype),
903 TREE_OPERAND (exp, 0));
905 if (TREE_CODE (exp) == COMPOUND_EXPR)
907 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
908 return build (COMPOUND_EXPR, TREE_TYPE (op1),
909 TREE_OPERAND (exp, 0), op1);
912 lvalue_array_p = !not_lvalue && lvalue_p (exp);
913 if (!flag_isoc99 && !lvalue_array_p)
915 /* Before C99, non-lvalue arrays do not decay to pointers.
916 Normally, using such an array would be invalid; but it can
917 be used correctly inside sizeof or as a statement expression.
918 Thus, do not give an error here; an error will result later. */
922 ptrtype = build_pointer_type (restype);
924 if (TREE_CODE (exp) == VAR_DECL)
926 /* ??? This is not really quite correct
927 in that the type of the operand of ADDR_EXPR
928 is not the target type of the type of the ADDR_EXPR itself.
929 Question is, can this lossage be avoided? */
930 adr = build1 (ADDR_EXPR, ptrtype, exp);
931 if (mark_addressable (exp) == 0)
932 return error_mark_node;
933 TREE_CONSTANT (adr) = staticp (exp);
934 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
937 /* This way is better for a COMPONENT_REF since it can
938 simplify the offset for a component. */
939 adr = build_unary_op (ADDR_EXPR, exp, 1);
940 return convert (ptrtype, adr);
945 /* Perform default promotions for C data used in expressions.
946 Arrays and functions are converted to pointers;
947 enumeral types or short or char, to int.
948 In addition, manifest constants symbols are replaced by their values. */
951 default_conversion (exp)
955 tree type = TREE_TYPE (exp);
956 enum tree_code code = TREE_CODE (type);
958 if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
959 return default_function_array_conversion (exp);
961 /* Constants can be used directly unless they're not loadable. */
962 if (TREE_CODE (exp) == CONST_DECL)
963 exp = DECL_INITIAL (exp);
965 /* Replace a nonvolatile const static variable with its value unless
966 it is an array, in which case we must be sure that taking the
967 address of the array produces consistent results. */
968 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
970 exp = decl_constant_value_for_broken_optimization (exp);
971 type = TREE_TYPE (exp);
974 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
977 Do not use STRIP_NOPS here! It will remove conversions from pointer
978 to integer and cause infinite recursion. */
980 while (TREE_CODE (exp) == NON_LVALUE_EXPR
981 || (TREE_CODE (exp) == NOP_EXPR
982 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
983 exp = TREE_OPERAND (exp, 0);
985 /* Preserve the original expression code. */
986 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
987 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
989 /* Normally convert enums to int,
990 but convert wide enums to something wider. */
991 if (code == ENUMERAL_TYPE)
993 type = type_for_size (MAX (TYPE_PRECISION (type),
994 TYPE_PRECISION (integer_type_node)),
996 || (TYPE_PRECISION (type)
997 >= TYPE_PRECISION (integer_type_node)))
998 && TREE_UNSIGNED (type)));
1000 return convert (type, exp);
1003 if (TREE_CODE (exp) == COMPONENT_REF
1004 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1005 /* If it's thinner than an int, promote it like a
1006 c_promoting_integer_type_p, otherwise leave it alone. */
1007 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1008 TYPE_PRECISION (integer_type_node)))
1009 return convert (flag_traditional && TREE_UNSIGNED (type)
1010 ? unsigned_type_node : integer_type_node,
1013 if (c_promoting_integer_type_p (type))
1015 /* Traditionally, unsignedness is preserved in default promotions.
1016 Also preserve unsignedness if not really getting any wider. */
1017 if (TREE_UNSIGNED (type)
1018 && (flag_traditional
1019 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1020 return convert (unsigned_type_node, exp);
1022 return convert (integer_type_node, exp);
1025 if (flag_traditional && !flag_allow_single_precision
1026 && TYPE_MAIN_VARIANT (type) == float_type_node)
1027 return convert (double_type_node, exp);
1029 if (code == VOID_TYPE)
1031 error ("void value not ignored as it ought to be");
1032 return error_mark_node;
1037 /* Look up COMPONENT in a structure or union DECL.
1039 If the component name is not found, returns NULL_TREE. Otherwise,
1040 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1041 stepping down the chain to the component, which is in the last
1042 TREE_VALUE of the list. Normally the list is of length one, but if
1043 the component is embedded within (nested) anonymous structures or
1044 unions, the list steps down the chain to the component. */
1047 lookup_field (decl, component)
1048 tree decl, component;
1050 tree type = TREE_TYPE (decl);
1053 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1054 to the field elements. Use a binary search on this array to quickly
1055 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1056 will always be set for structures which have many elements. */
1058 if (TYPE_LANG_SPECIFIC (type))
1061 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1063 field = TYPE_FIELDS (type);
1065 top = TYPE_LANG_SPECIFIC (type)->len;
1066 while (top - bot > 1)
1068 half = (top - bot + 1) >> 1;
1069 field = field_array[bot+half];
1071 if (DECL_NAME (field) == NULL_TREE)
1073 /* Step through all anon unions in linear fashion. */
1074 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1076 field = field_array[bot++];
1077 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1078 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1080 tree anon = lookup_field (field, component);
1083 return tree_cons (NULL_TREE, field, anon);
1087 /* Entire record is only anon unions. */
1091 /* Restart the binary search, with new lower bound. */
1095 if (DECL_NAME (field) == component)
1097 if (DECL_NAME (field) < component)
1103 if (DECL_NAME (field_array[bot]) == component)
1104 field = field_array[bot];
1105 else if (DECL_NAME (field) != component)
1110 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1112 if (DECL_NAME (field) == NULL_TREE
1113 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1114 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1116 tree anon = lookup_field (field, component);
1119 return tree_cons (NULL_TREE, field, anon);
1122 if (DECL_NAME (field) == component)
1126 if (field == NULL_TREE)
1130 return tree_cons (NULL_TREE, field, NULL_TREE);
1133 /* Make an expression to refer to the COMPONENT field of
1134 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1137 build_component_ref (datum, component)
1138 tree datum, component;
1140 tree type = TREE_TYPE (datum);
1141 enum tree_code code = TREE_CODE (type);
1145 /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
1146 If pedantic ensure that the arguments are not lvalues; otherwise,
1147 if the component is an array, it would wrongly decay to a pointer in
1149 We cannot do this with a COND_EXPR, because in a conditional expression
1150 the default promotions are applied to both sides, and this would yield
1151 the wrong type of the result; for example, if the components have
1153 switch (TREE_CODE (datum))
1157 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1158 return build (COMPOUND_EXPR, TREE_TYPE (value),
1159 TREE_OPERAND (datum, 0), pedantic_non_lvalue (value));
1165 /* See if there is a field or component with name COMPONENT. */
1167 if (code == RECORD_TYPE || code == UNION_TYPE)
1169 if (!COMPLETE_TYPE_P (type))
1171 incomplete_type_error (NULL_TREE, type);
1172 return error_mark_node;
1175 field = lookup_field (datum, component);
1179 error ("%s has no member named `%s'",
1180 code == RECORD_TYPE ? "structure" : "union",
1181 IDENTIFIER_POINTER (component));
1182 return error_mark_node;
1185 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1186 This might be better solved in future the way the C++ front
1187 end does it - by giving the anonymous entities each a
1188 separate name and type, and then have build_component_ref
1189 recursively call itself. We can't do that here. */
1190 for (; field; field = TREE_CHAIN (field))
1192 tree subdatum = TREE_VALUE (field);
1194 if (TREE_TYPE (subdatum) == error_mark_node)
1195 return error_mark_node;
1197 ref = build (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum);
1198 if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1199 TREE_READONLY (ref) = 1;
1200 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1201 TREE_THIS_VOLATILE (ref) = 1;
1207 else if (code != ERROR_MARK)
1208 error ("request for member `%s' in something not a structure or union",
1209 IDENTIFIER_POINTER (component));
1211 return error_mark_node;
1214 /* Given an expression PTR for a pointer, return an expression
1215 for the value pointed to.
1216 ERRORSTRING is the name of the operator to appear in error messages. */
1219 build_indirect_ref (ptr, errorstring)
1221 const char *errorstring;
1223 tree pointer = default_conversion (ptr);
1224 tree type = TREE_TYPE (pointer);
1226 if (TREE_CODE (type) == POINTER_TYPE)
1228 if (TREE_CODE (pointer) == ADDR_EXPR
1230 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1231 == TREE_TYPE (type)))
1232 return TREE_OPERAND (pointer, 0);
1235 tree t = TREE_TYPE (type);
1236 tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1238 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1240 error ("dereferencing pointer to incomplete type");
1241 return error_mark_node;
1243 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1244 warning ("dereferencing `void *' pointer");
1246 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1247 so that we get the proper error message if the result is used
1248 to assign to. Also, &* is supposed to be a no-op.
1249 And ANSI C seems to specify that the type of the result
1250 should be the const type. */
1251 /* A de-reference of a pointer to const is not a const. It is valid
1252 to change it via some other pointer. */
1253 TREE_READONLY (ref) = TYPE_READONLY (t);
1254 TREE_SIDE_EFFECTS (ref)
1255 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1256 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1260 else if (TREE_CODE (pointer) != ERROR_MARK)
1261 error ("invalid type argument of `%s'", errorstring);
1262 return error_mark_node;
1265 /* This handles expressions of the form "a[i]", which denotes
1268 This is logically equivalent in C to *(a+i), but we may do it differently.
1269 If A is a variable or a member, we generate a primitive ARRAY_REF.
1270 This avoids forcing the array out of registers, and can work on
1271 arrays that are not lvalues (for example, members of structures returned
1275 build_array_ref (array, index)
1280 error ("subscript missing in array reference");
1281 return error_mark_node;
1284 if (TREE_TYPE (array) == error_mark_node
1285 || TREE_TYPE (index) == error_mark_node)
1286 return error_mark_node;
1288 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1289 && TREE_CODE (array) != INDIRECT_REF)
1293 /* Subscripting with type char is likely to lose
1294 on a machine where chars are signed.
1295 So warn on any machine, but optionally.
1296 Don't warn for unsigned char since that type is safe.
1297 Don't warn for signed char because anyone who uses that
1298 must have done so deliberately. */
1299 if (warn_char_subscripts
1300 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1301 warning ("array subscript has type `char'");
1303 /* Apply default promotions *after* noticing character types. */
1304 index = default_conversion (index);
1306 /* Require integer *after* promotion, for sake of enums. */
1307 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1309 error ("array subscript is not an integer");
1310 return error_mark_node;
1313 /* An array that is indexed by a non-constant
1314 cannot be stored in a register; we must be able to do
1315 address arithmetic on its address.
1316 Likewise an array of elements of variable size. */
1317 if (TREE_CODE (index) != INTEGER_CST
1318 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1319 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1321 if (mark_addressable (array) == 0)
1322 return error_mark_node;
1324 /* An array that is indexed by a constant value which is not within
1325 the array bounds cannot be stored in a register either; because we
1326 would get a crash in store_bit_field/extract_bit_field when trying
1327 to access a non-existent part of the register. */
1328 if (TREE_CODE (index) == INTEGER_CST
1329 && TYPE_VALUES (TREE_TYPE (array))
1330 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1332 if (mark_addressable (array) == 0)
1333 return error_mark_node;
1339 while (TREE_CODE (foo) == COMPONENT_REF)
1340 foo = TREE_OPERAND (foo, 0);
1341 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1342 pedwarn ("ISO C forbids subscripting `register' array");
1343 else if (! flag_isoc99 && ! lvalue_p (foo))
1344 pedwarn ("ISO C89 forbids subscripting non-lvalue array");
1347 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1348 rval = build (ARRAY_REF, type, array, index);
1349 /* Array ref is const/volatile if the array elements are
1350 or if the array is. */
1351 TREE_READONLY (rval)
1352 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1353 | TREE_READONLY (array));
1354 TREE_SIDE_EFFECTS (rval)
1355 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1356 | TREE_SIDE_EFFECTS (array));
1357 TREE_THIS_VOLATILE (rval)
1358 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1359 /* This was added by rms on 16 Nov 91.
1360 It fixes vol struct foo *a; a->elts[1]
1361 in an inline function.
1362 Hope it doesn't break something else. */
1363 | TREE_THIS_VOLATILE (array));
1364 return require_complete_type (fold (rval));
1368 tree ar = default_conversion (array);
1369 tree ind = default_conversion (index);
1371 /* Do the same warning check as above, but only on the part that's
1372 syntactically the index and only if it is also semantically
1374 if (warn_char_subscripts
1375 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1376 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1377 warning ("subscript has type `char'");
1379 /* Put the integer in IND to simplify error checking. */
1380 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1387 if (ar == error_mark_node)
1390 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1391 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1393 error ("subscripted value is neither array nor pointer");
1394 return error_mark_node;
1396 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1398 error ("array subscript is not an integer");
1399 return error_mark_node;
1402 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1407 /* Build an external reference to identifier ID. FUN indicates
1408 whether this will be used for a function call. */
1410 build_external_ref (id, fun)
1415 tree decl = lookup_name (id);
1416 tree objc_ivar = lookup_objc_ivar (id);
1418 if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
1424 if (!decl || decl == error_mark_node)
1425 /* Ordinary implicit function declaration. */
1426 ref = implicitly_declare (id);
1429 /* Implicit declaration of built-in function. Don't
1430 change the built-in declaration, but don't let this
1431 go by silently, either. */
1432 implicit_decl_warning (id);
1434 /* only issue this warning once */
1435 C_DECL_ANTICIPATED (decl) = 0;
1441 /* Reference to undeclared variable, including reference to
1442 builtin outside of function-call context. */
1443 if (current_function_decl == 0)
1444 error ("`%s' undeclared here (not in a function)",
1445 IDENTIFIER_POINTER (id));
1448 if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node
1449 || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl)
1451 error ("`%s' undeclared (first use in this function)",
1452 IDENTIFIER_POINTER (id));
1454 if (! undeclared_variable_notice)
1456 error ("(Each undeclared identifier is reported only once");
1457 error ("for each function it appears in.)");
1458 undeclared_variable_notice = 1;
1461 IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node;
1462 IDENTIFIER_ERROR_LOCUS (id) = current_function_decl;
1464 return error_mark_node;
1469 /* Properly declared variable or function reference. */
1472 else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
1474 warning ("local declaration of `%s' hides instance variable",
1475 IDENTIFIER_POINTER (id));
1482 if (TREE_TYPE (ref) == error_mark_node)
1483 return error_mark_node;
1485 assemble_external (ref);
1486 TREE_USED (ref) = 1;
1488 if (TREE_CODE (ref) == CONST_DECL)
1490 ref = DECL_INITIAL (ref);
1491 TREE_CONSTANT (ref) = 1;
1497 /* Build a function call to function FUNCTION with parameters PARAMS.
1498 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1499 TREE_VALUE of each node is a parameter-expression.
1500 FUNCTION's data type may be a function type or a pointer-to-function. */
1503 build_function_call (function, params)
1504 tree function, params;
1506 tree fntype, fundecl = 0;
1507 tree coerced_params;
1508 tree name = NULL_TREE, assembler_name = NULL_TREE, result;
1510 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1511 STRIP_TYPE_NOPS (function);
1513 /* Convert anything with function type to a pointer-to-function. */
1514 if (TREE_CODE (function) == FUNCTION_DECL)
1516 name = DECL_NAME (function);
1517 assembler_name = DECL_ASSEMBLER_NAME (function);
1519 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1520 (because calling an inline function does not mean the function
1521 needs to be separately compiled). */
1522 fntype = build_type_variant (TREE_TYPE (function),
1523 TREE_READONLY (function),
1524 TREE_THIS_VOLATILE (function));
1526 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1529 function = default_conversion (function);
1531 fntype = TREE_TYPE (function);
1533 if (TREE_CODE (fntype) == ERROR_MARK)
1534 return error_mark_node;
1536 if (!(TREE_CODE (fntype) == POINTER_TYPE
1537 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1539 error ("called object is not a function");
1540 return error_mark_node;
1543 /* fntype now gets the type of function pointed to. */
1544 fntype = TREE_TYPE (fntype);
1546 /* Convert the parameters to the types declared in the
1547 function prototype, or apply default promotions. */
1550 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1552 /* Check for errors in format strings. */
1555 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
1557 /* Recognize certain built-in functions so we can make tree-codes
1558 other than CALL_EXPR. We do this when it enables fold-const.c
1559 to do something useful. */
1561 if (TREE_CODE (function) == ADDR_EXPR
1562 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1563 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1565 result = expand_tree_builtin (TREE_OPERAND (function, 0),
1566 params, coerced_params);
1571 result = build (CALL_EXPR, TREE_TYPE (fntype),
1572 function, coerced_params, NULL_TREE);
1573 TREE_SIDE_EFFECTS (result) = 1;
1574 result = fold (result);
1576 if (VOID_TYPE_P (TREE_TYPE (result)))
1578 return require_complete_type (result);
1581 /* Convert the argument expressions in the list VALUES
1582 to the types in the list TYPELIST. The result is a list of converted
1583 argument expressions.
1585 If TYPELIST is exhausted, or when an element has NULL as its type,
1586 perform the default conversions.
1588 PARMLIST is the chain of parm decls for the function being called.
1589 It may be 0, if that info is not available.
1590 It is used only for generating error messages.
1592 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1594 This is also where warnings about wrong number of args are generated.
1596 Both VALUES and the returned value are chains of TREE_LIST nodes
1597 with the elements of the list in the TREE_VALUE slots of those nodes. */
1600 convert_arguments (typelist, values, name, fundecl)
1601 tree typelist, values, name, fundecl;
1603 tree typetail, valtail;
1607 /* Scan the given expressions and types, producing individual
1608 converted arguments and pushing them on RESULT in reverse order. */
1610 for (valtail = values, typetail = typelist, parmnum = 0;
1612 valtail = TREE_CHAIN (valtail), parmnum++)
1614 tree type = typetail ? TREE_VALUE (typetail) : 0;
1615 tree val = TREE_VALUE (valtail);
1617 if (type == void_type_node)
1620 error ("too many arguments to function `%s'",
1621 IDENTIFIER_POINTER (name));
1623 error ("too many arguments to function");
1627 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1628 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1629 to convert automatically to a pointer. */
1630 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1631 val = TREE_OPERAND (val, 0);
1633 val = default_function_array_conversion (val);
1635 val = require_complete_type (val);
1639 /* Formal parm type is specified by a function prototype. */
1642 if (!COMPLETE_TYPE_P (type))
1644 error ("type of formal parameter %d is incomplete", parmnum + 1);
1649 /* Optionally warn about conversions that
1650 differ from the default conversions. */
1651 if (warn_conversion || warn_traditional)
1653 int formal_prec = TYPE_PRECISION (type);
1655 if (INTEGRAL_TYPE_P (type)
1656 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1657 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1658 if (INTEGRAL_TYPE_P (type)
1659 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1660 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1661 else if (TREE_CODE (type) == COMPLEX_TYPE
1662 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1663 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1664 else if (TREE_CODE (type) == REAL_TYPE
1665 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1666 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1667 else if (TREE_CODE (type) == COMPLEX_TYPE
1668 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1669 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1670 else if (TREE_CODE (type) == REAL_TYPE
1671 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1672 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1673 /* ??? At some point, messages should be written about
1674 conversions between complex types, but that's too messy
1676 else if (TREE_CODE (type) == REAL_TYPE
1677 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1679 /* Warn if any argument is passed as `float',
1680 since without a prototype it would be `double'. */
1681 if (formal_prec == TYPE_PRECISION (float_type_node))
1682 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1684 /* Detect integer changing in width or signedness.
1685 These warnings are only activated with
1686 -Wconversion, not with -Wtraditional. */
1687 else if (warn_conversion && INTEGRAL_TYPE_P (type)
1688 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1690 tree would_have_been = default_conversion (val);
1691 tree type1 = TREE_TYPE (would_have_been);
1693 if (TREE_CODE (type) == ENUMERAL_TYPE
1694 && (TYPE_MAIN_VARIANT (type)
1695 == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
1696 /* No warning if function asks for enum
1697 and the actual arg is that enum type. */
1699 else if (formal_prec != TYPE_PRECISION (type1))
1700 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1701 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1703 /* Don't complain if the formal parameter type
1704 is an enum, because we can't tell now whether
1705 the value was an enum--even the same enum. */
1706 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1708 else if (TREE_CODE (val) == INTEGER_CST
1709 && int_fits_type_p (val, type))
1710 /* Change in signedness doesn't matter
1711 if a constant value is unaffected. */
1713 /* Likewise for a constant in a NOP_EXPR. */
1714 else if (TREE_CODE (val) == NOP_EXPR
1715 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1716 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1718 #if 0 /* We never get such tree structure here. */
1719 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1720 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1721 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1722 /* Change in signedness doesn't matter
1723 if an enum value is unaffected. */
1726 /* If the value is extended from a narrower
1727 unsigned type, it doesn't matter whether we
1728 pass it as signed or unsigned; the value
1729 certainly is the same either way. */
1730 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1731 && TREE_UNSIGNED (TREE_TYPE (val)))
1733 else if (TREE_UNSIGNED (type))
1734 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1736 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1740 parmval = convert_for_assignment (type, val,
1741 (char *) 0, /* arg passing */
1742 fundecl, name, parmnum + 1);
1744 if (PROMOTE_PROTOTYPES
1745 && INTEGRAL_TYPE_P (type)
1746 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1747 parmval = default_conversion (parmval);
1749 result = tree_cons (NULL_TREE, parmval, result);
1751 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1752 && (TYPE_PRECISION (TREE_TYPE (val))
1753 < TYPE_PRECISION (double_type_node)))
1754 /* Convert `float' to `double'. */
1755 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1757 /* Convert `short' and `char' to full-size `int'. */
1758 result = tree_cons (NULL_TREE, default_conversion (val), result);
1761 typetail = TREE_CHAIN (typetail);
1764 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1767 error ("too few arguments to function `%s'",
1768 IDENTIFIER_POINTER (name));
1770 error ("too few arguments to function");
1773 return nreverse (result);
1776 /* This is the entry point used by the parser
1777 for binary operators in the input.
1778 In addition to constructing the expression,
1779 we check for operands that were written with other binary operators
1780 in a way that is likely to confuse the user. */
1783 parser_build_binary_op (code, arg1, arg2)
1784 enum tree_code code;
1787 tree result = build_binary_op (code, arg1, arg2, 1);
1790 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1791 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1792 enum tree_code code1 = ERROR_MARK;
1793 enum tree_code code2 = ERROR_MARK;
1795 if (IS_EXPR_CODE_CLASS (class1))
1796 code1 = C_EXP_ORIGINAL_CODE (arg1);
1797 if (IS_EXPR_CODE_CLASS (class2))
1798 code2 = C_EXP_ORIGINAL_CODE (arg2);
1800 /* Check for cases such as x+y<<z which users are likely
1801 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1802 is cleared to prevent these warnings. */
1803 if (warn_parentheses)
1805 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1807 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1808 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1809 warning ("suggest parentheses around + or - inside shift");
1812 if (code == TRUTH_ORIF_EXPR)
1814 if (code1 == TRUTH_ANDIF_EXPR
1815 || code2 == TRUTH_ANDIF_EXPR)
1816 warning ("suggest parentheses around && within ||");
1819 if (code == BIT_IOR_EXPR)
1821 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1822 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1823 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1824 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1825 warning ("suggest parentheses around arithmetic in operand of |");
1826 /* Check cases like x|y==z */
1827 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1828 warning ("suggest parentheses around comparison in operand of |");
1831 if (code == BIT_XOR_EXPR)
1833 if (code1 == BIT_AND_EXPR
1834 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1835 || code2 == BIT_AND_EXPR
1836 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1837 warning ("suggest parentheses around arithmetic in operand of ^");
1838 /* Check cases like x^y==z */
1839 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1840 warning ("suggest parentheses around comparison in operand of ^");
1843 if (code == BIT_AND_EXPR)
1845 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1846 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1847 warning ("suggest parentheses around + or - in operand of &");
1848 /* Check cases like x&y==z */
1849 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1850 warning ("suggest parentheses around comparison in operand of &");
1854 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1855 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1856 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1857 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1859 unsigned_conversion_warning (result, arg1);
1860 unsigned_conversion_warning (result, arg2);
1861 overflow_warning (result);
1863 class = TREE_CODE_CLASS (TREE_CODE (result));
1865 /* Record the code that was specified in the source,
1866 for the sake of warnings about confusing nesting. */
1867 if (IS_EXPR_CODE_CLASS (class))
1868 C_SET_EXP_ORIGINAL_CODE (result, code);
1871 int flag = TREE_CONSTANT (result);
1872 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1873 so that convert_for_assignment wouldn't strip it.
1874 That way, we got warnings for things like p = (1 - 1).
1875 But it turns out we should not get those warnings. */
1876 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1877 C_SET_EXP_ORIGINAL_CODE (result, code);
1878 TREE_CONSTANT (result) = flag;
1884 /* Build a binary-operation expression without default conversions.
1885 CODE is the kind of expression to build.
1886 This function differs from `build' in several ways:
1887 the data type of the result is computed and recorded in it,
1888 warnings are generated if arg data types are invalid,
1889 special handling for addition and subtraction of pointers is known,
1890 and some optimization is done (operations on narrow ints
1891 are done in the narrower type when that gives the same result).
1892 Constant folding is also done before the result is returned.
1894 Note that the operands will never have enumeral types, or function
1895 or array types, because either they will have the default conversions
1896 performed or they have both just been converted to some other type in which
1897 the arithmetic is to be done. */
1900 build_binary_op (code, orig_op0, orig_op1, convert_p)
1901 enum tree_code code;
1902 tree orig_op0, orig_op1;
1906 enum tree_code code0, code1;
1909 /* Expression code to give to the expression when it is built.
1910 Normally this is CODE, which is what the caller asked for,
1911 but in some special cases we change it. */
1912 enum tree_code resultcode = code;
1914 /* Data type in which the computation is to be performed.
1915 In the simplest cases this is the common type of the arguments. */
1916 tree result_type = NULL;
1918 /* Nonzero means operands have already been type-converted
1919 in whatever way is necessary.
1920 Zero means they need to be converted to RESULT_TYPE. */
1923 /* Nonzero means create the expression with this type, rather than
1925 tree build_type = 0;
1927 /* Nonzero means after finally constructing the expression
1928 convert it to this type. */
1929 tree final_type = 0;
1931 /* Nonzero if this is an operation like MIN or MAX which can
1932 safely be computed in short if both args are promoted shorts.
1933 Also implies COMMON.
1934 -1 indicates a bitwise operation; this makes a difference
1935 in the exact conditions for when it is safe to do the operation
1936 in a narrower mode. */
1939 /* Nonzero if this is a comparison operation;
1940 if both args are promoted shorts, compare the original shorts.
1941 Also implies COMMON. */
1942 int short_compare = 0;
1944 /* Nonzero if this is a right-shift operation, which can be computed on the
1945 original short and then promoted if the operand is a promoted short. */
1946 int short_shift = 0;
1948 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1953 op0 = default_conversion (orig_op0);
1954 op1 = default_conversion (orig_op1);
1962 type0 = TREE_TYPE (op0);
1963 type1 = TREE_TYPE (op1);
1965 /* The expression codes of the data types of the arguments tell us
1966 whether the arguments are integers, floating, pointers, etc. */
1967 code0 = TREE_CODE (type0);
1968 code1 = TREE_CODE (type1);
1970 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1971 STRIP_TYPE_NOPS (op0);
1972 STRIP_TYPE_NOPS (op1);
1974 /* If an error was already reported for one of the arguments,
1975 avoid reporting another error. */
1977 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
1978 return error_mark_node;
1983 /* Handle the pointer + int case. */
1984 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1985 return pointer_int_sum (PLUS_EXPR, op0, op1);
1986 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
1987 return pointer_int_sum (PLUS_EXPR, op1, op0);
1993 /* Subtraction of two similar pointers.
1994 We must subtract them as integers, then divide by object size. */
1995 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
1996 && comp_target_types (type0, type1))
1997 return pointer_diff (op0, op1);
1998 /* Handle pointer minus int. Just like pointer plus int. */
1999 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2000 return pointer_int_sum (MINUS_EXPR, op0, op1);
2009 case TRUNC_DIV_EXPR:
2011 case FLOOR_DIV_EXPR:
2012 case ROUND_DIV_EXPR:
2013 case EXACT_DIV_EXPR:
2014 /* Floating point division by zero is a legitimate way to obtain
2015 infinities and NaNs. */
2016 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2017 warning ("division by zero");
2019 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2020 || code0 == COMPLEX_TYPE)
2021 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2022 || code1 == COMPLEX_TYPE))
2024 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2025 resultcode = RDIV_EXPR;
2027 /* Although it would be tempting to shorten always here, that
2028 loses on some targets, since the modulo instruction is
2029 undefined if the quotient can't be represented in the
2030 computation mode. We shorten only if unsigned or if
2031 dividing by something we know != -1. */
2032 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2033 || (TREE_CODE (op1) == INTEGER_CST
2034 && ! integer_all_onesp (op1)));
2040 case BIT_ANDTC_EXPR:
2043 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2045 /* If one operand is a constant, and the other is a short type
2046 that has been converted to an int,
2047 really do the work in the short type and then convert the
2048 result to int. If we are lucky, the constant will be 0 or 1
2049 in the short type, making the entire operation go away. */
2050 if (TREE_CODE (op0) == INTEGER_CST
2051 && TREE_CODE (op1) == NOP_EXPR
2052 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2053 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2055 final_type = result_type;
2056 op1 = TREE_OPERAND (op1, 0);
2057 result_type = TREE_TYPE (op1);
2059 if (TREE_CODE (op1) == INTEGER_CST
2060 && TREE_CODE (op0) == NOP_EXPR
2061 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2062 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2064 final_type = result_type;
2065 op0 = TREE_OPERAND (op0, 0);
2066 result_type = TREE_TYPE (op0);
2070 case TRUNC_MOD_EXPR:
2071 case FLOOR_MOD_EXPR:
2072 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2073 warning ("division by zero");
2075 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2077 /* Although it would be tempting to shorten always here, that loses
2078 on some targets, since the modulo instruction is undefined if the
2079 quotient can't be represented in the computation mode. We shorten
2080 only if unsigned or if dividing by something we know != -1. */
2081 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2082 || (TREE_CODE (op1) == INTEGER_CST
2083 && ! integer_all_onesp (op1)));
2088 case TRUTH_ANDIF_EXPR:
2089 case TRUTH_ORIF_EXPR:
2090 case TRUTH_AND_EXPR:
2092 case TRUTH_XOR_EXPR:
2093 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2094 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2095 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2096 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2098 /* Result of these operations is always an int,
2099 but that does not mean the operands should be
2100 converted to ints! */
2101 result_type = integer_type_node;
2102 op0 = truthvalue_conversion (op0);
2103 op1 = truthvalue_conversion (op1);
2108 /* Shift operations: result has same type as first operand;
2109 always convert second operand to int.
2110 Also set SHORT_SHIFT if shifting rightward. */
2113 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2115 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2117 if (tree_int_cst_sgn (op1) < 0)
2118 warning ("right shift count is negative");
2121 if (! integer_zerop (op1))
2124 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2125 warning ("right shift count >= width of type");
2129 /* Use the type of the value to be shifted.
2130 This is what most traditional C compilers do. */
2131 result_type = type0;
2132 /* Unless traditional, convert the shift-count to an integer,
2133 regardless of size of value being shifted. */
2134 if (! flag_traditional)
2136 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2137 op1 = convert (integer_type_node, op1);
2138 /* Avoid converting op1 to result_type later. */
2145 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2147 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2149 if (tree_int_cst_sgn (op1) < 0)
2150 warning ("left shift count is negative");
2152 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2153 warning ("left shift count >= width of type");
2156 /* Use the type of the value to be shifted.
2157 This is what most traditional C compilers do. */
2158 result_type = type0;
2159 /* Unless traditional, convert the shift-count to an integer,
2160 regardless of size of value being shifted. */
2161 if (! flag_traditional)
2163 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2164 op1 = convert (integer_type_node, op1);
2165 /* Avoid converting op1 to result_type later. */
2173 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2175 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2177 if (tree_int_cst_sgn (op1) < 0)
2178 warning ("shift count is negative");
2179 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2180 warning ("shift count >= width of type");
2183 /* Use the type of the value to be shifted.
2184 This is what most traditional C compilers do. */
2185 result_type = type0;
2186 /* Unless traditional, convert the shift-count to an integer,
2187 regardless of size of value being shifted. */
2188 if (! flag_traditional)
2190 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2191 op1 = convert (integer_type_node, op1);
2192 /* Avoid converting op1 to result_type later. */
2200 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2201 warning ("comparing floating point with == or != is unsafe");
2202 /* Result of comparison is always int,
2203 but don't convert the args to int! */
2204 build_type = integer_type_node;
2205 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2206 || code0 == COMPLEX_TYPE)
2207 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2208 || code1 == COMPLEX_TYPE))
2210 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2212 tree tt0 = TREE_TYPE (type0);
2213 tree tt1 = TREE_TYPE (type1);
2214 /* Anything compares with void *. void * compares with anything.
2215 Otherwise, the targets must be compatible
2216 and both must be object or both incomplete. */
2217 if (comp_target_types (type0, type1))
2218 result_type = common_type (type0, type1);
2219 else if (VOID_TYPE_P (tt0))
2221 /* op0 != orig_op0 detects the case of something
2222 whose value is 0 but which isn't a valid null ptr const. */
2223 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2224 && TREE_CODE (tt1) == FUNCTION_TYPE)
2225 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2227 else if (VOID_TYPE_P (tt1))
2229 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2230 && TREE_CODE (tt0) == FUNCTION_TYPE)
2231 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2234 pedwarn ("comparison of distinct pointer types lacks a cast");
2236 if (result_type == NULL_TREE)
2237 result_type = ptr_type_node;
2239 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2240 && integer_zerop (op1))
2241 result_type = type0;
2242 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2243 && integer_zerop (op0))
2244 result_type = type1;
2245 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2247 result_type = type0;
2248 if (! flag_traditional)
2249 pedwarn ("comparison between pointer and integer");
2251 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2253 result_type = type1;
2254 if (! flag_traditional)
2255 pedwarn ("comparison between pointer and integer");
2261 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2262 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2264 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2266 if (comp_target_types (type0, type1))
2268 result_type = common_type (type0, type1);
2270 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2271 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2275 result_type = ptr_type_node;
2276 pedwarn ("comparison of distinct pointer types lacks a cast");
2285 build_type = integer_type_node;
2286 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2287 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2289 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2291 if (comp_target_types (type0, type1))
2293 result_type = common_type (type0, type1);
2294 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2295 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2296 pedwarn ("comparison of complete and incomplete pointers");
2298 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2299 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2303 result_type = ptr_type_node;
2304 pedwarn ("comparison of distinct pointer types lacks a cast");
2307 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2308 && integer_zerop (op1))
2310 result_type = type0;
2311 if (pedantic || extra_warnings)
2312 pedwarn ("ordered comparison of pointer with integer zero");
2314 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2315 && integer_zerop (op0))
2317 result_type = type1;
2319 pedwarn ("ordered comparison of pointer with integer zero");
2321 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2323 result_type = type0;
2324 if (! flag_traditional)
2325 pedwarn ("comparison between pointer and integer");
2327 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2329 result_type = type1;
2330 if (! flag_traditional)
2331 pedwarn ("comparison between pointer and integer");
2335 case UNORDERED_EXPR:
2342 build_type = integer_type_node;
2343 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2345 error ("unordered comparison on non-floating point argument");
2346 return error_mark_node;
2355 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2357 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2359 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2361 if (shorten || common || short_compare)
2362 result_type = common_type (type0, type1);
2364 /* For certain operations (which identify themselves by shorten != 0)
2365 if both args were extended from the same smaller type,
2366 do the arithmetic in that type and then extend.
2368 shorten !=0 and !=1 indicates a bitwise operation.
2369 For them, this optimization is safe only if
2370 both args are zero-extended or both are sign-extended.
2371 Otherwise, we might change the result.
2372 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2373 but calculated in (unsigned short) it would be (unsigned short)-1. */
2375 if (shorten && none_complex)
2377 int unsigned0, unsigned1;
2378 tree arg0 = get_narrower (op0, &unsigned0);
2379 tree arg1 = get_narrower (op1, &unsigned1);
2380 /* UNS is 1 if the operation to be done is an unsigned one. */
2381 int uns = TREE_UNSIGNED (result_type);
2384 final_type = result_type;
2386 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2387 but it *requires* conversion to FINAL_TYPE. */
2389 if ((TYPE_PRECISION (TREE_TYPE (op0))
2390 == TYPE_PRECISION (TREE_TYPE (arg0)))
2391 && TREE_TYPE (op0) != final_type)
2392 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2393 if ((TYPE_PRECISION (TREE_TYPE (op1))
2394 == TYPE_PRECISION (TREE_TYPE (arg1)))
2395 && TREE_TYPE (op1) != final_type)
2396 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2398 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2400 /* For bitwise operations, signedness of nominal type
2401 does not matter. Consider only how operands were extended. */
2405 /* Note that in all three cases below we refrain from optimizing
2406 an unsigned operation on sign-extended args.
2407 That would not be valid. */
2409 /* Both args variable: if both extended in same way
2410 from same width, do it in that width.
2411 Do it unsigned if args were zero-extended. */
2412 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2413 < TYPE_PRECISION (result_type))
2414 && (TYPE_PRECISION (TREE_TYPE (arg1))
2415 == TYPE_PRECISION (TREE_TYPE (arg0)))
2416 && unsigned0 == unsigned1
2417 && (unsigned0 || !uns))
2419 = signed_or_unsigned_type (unsigned0,
2420 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2421 else if (TREE_CODE (arg0) == INTEGER_CST
2422 && (unsigned1 || !uns)
2423 && (TYPE_PRECISION (TREE_TYPE (arg1))
2424 < TYPE_PRECISION (result_type))
2425 && (type = signed_or_unsigned_type (unsigned1,
2427 int_fits_type_p (arg0, type)))
2429 else if (TREE_CODE (arg1) == INTEGER_CST
2430 && (unsigned0 || !uns)
2431 && (TYPE_PRECISION (TREE_TYPE (arg0))
2432 < TYPE_PRECISION (result_type))
2433 && (type = signed_or_unsigned_type (unsigned0,
2435 int_fits_type_p (arg1, type)))
2439 /* Shifts can be shortened if shifting right. */
2444 tree arg0 = get_narrower (op0, &unsigned_arg);
2446 final_type = result_type;
2448 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2449 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2451 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2452 /* We can shorten only if the shift count is less than the
2453 number of bits in the smaller type size. */
2454 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2455 /* We cannot drop an unsigned shift after sign-extension. */
2456 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2458 /* Do an unsigned shift if the operand was zero-extended. */
2460 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
2461 /* Convert value-to-be-shifted to that type. */
2462 if (TREE_TYPE (op0) != result_type)
2463 op0 = convert (result_type, op0);
2468 /* Comparison operations are shortened too but differently.
2469 They identify themselves by setting short_compare = 1. */
2473 /* Don't write &op0, etc., because that would prevent op0
2474 from being kept in a register.
2475 Instead, make copies of the our local variables and
2476 pass the copies by reference, then copy them back afterward. */
2477 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2478 enum tree_code xresultcode = resultcode;
2480 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2485 op0 = xop0, op1 = xop1;
2487 resultcode = xresultcode;
2489 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2490 && skip_evaluation == 0)
2492 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2493 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2494 int unsignedp0, unsignedp1;
2495 tree primop0 = get_narrower (op0, &unsignedp0);
2496 tree primop1 = get_narrower (op1, &unsignedp1);
2500 STRIP_TYPE_NOPS (xop0);
2501 STRIP_TYPE_NOPS (xop1);
2503 /* Give warnings for comparisons between signed and unsigned
2504 quantities that may fail.
2506 Do the checking based on the original operand trees, so that
2507 casts will be considered, but default promotions won't be.
2509 Do not warn if the comparison is being done in a signed type,
2510 since the signed type will only be chosen if it can represent
2511 all the values of the unsigned type. */
2512 if (! TREE_UNSIGNED (result_type))
2514 /* Do not warn if both operands are the same signedness. */
2515 else if (op0_signed == op1_signed)
2522 sop = xop0, uop = xop1;
2524 sop = xop1, uop = xop0;
2526 /* Do not warn if the signed quantity is an
2527 unsuffixed integer literal (or some static
2528 constant expression involving such literals or a
2529 conditional expression involving such literals)
2530 and it is non-negative. */
2531 if (tree_expr_nonnegative_p (sop))
2533 /* Do not warn if the comparison is an equality operation,
2534 the unsigned quantity is an integral constant, and it
2535 would fit in the result if the result were signed. */
2536 else if (TREE_CODE (uop) == INTEGER_CST
2537 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2538 && int_fits_type_p (uop, signed_type (result_type)))
2540 /* Do not warn if the unsigned quantity is an enumeration
2541 constant and its maximum value would fit in the result
2542 if the result were signed. */
2543 else if (TREE_CODE (uop) == INTEGER_CST
2544 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2545 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2546 signed_type (result_type)))
2549 warning ("comparison between signed and unsigned");
2552 /* Warn if two unsigned values are being compared in a size
2553 larger than their original size, and one (and only one) is the
2554 result of a `~' operator. This comparison will always fail.
2556 Also warn if one operand is a constant, and the constant
2557 does not have all bits set that are set in the ~ operand
2558 when it is extended. */
2560 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2561 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2563 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2564 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2567 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2570 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2573 HOST_WIDE_INT constant, mask;
2574 int unsignedp, bits;
2576 if (host_integerp (primop0, 0))
2579 unsignedp = unsignedp1;
2580 constant = tree_low_cst (primop0, 0);
2585 unsignedp = unsignedp0;
2586 constant = tree_low_cst (primop1, 0);
2589 bits = TYPE_PRECISION (TREE_TYPE (primop));
2590 if (bits < TYPE_PRECISION (result_type)
2591 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2593 mask = (~ (HOST_WIDE_INT) 0) << bits;
2594 if ((mask & constant) != mask)
2595 warning ("comparison of promoted ~unsigned with constant");
2598 else if (unsignedp0 && unsignedp1
2599 && (TYPE_PRECISION (TREE_TYPE (primop0))
2600 < TYPE_PRECISION (result_type))
2601 && (TYPE_PRECISION (TREE_TYPE (primop1))
2602 < TYPE_PRECISION (result_type)))
2603 warning ("comparison of promoted ~unsigned with unsigned");
2609 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2610 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2611 Then the expression will be built.
2612 It will be given type FINAL_TYPE if that is nonzero;
2613 otherwise, it will be given type RESULT_TYPE. */
2617 binary_op_error (code);
2618 return error_mark_node;
2623 if (TREE_TYPE (op0) != result_type)
2624 op0 = convert (result_type, op0);
2625 if (TREE_TYPE (op1) != result_type)
2626 op1 = convert (result_type, op1);
2629 if (build_type == NULL_TREE)
2630 build_type = result_type;
2633 tree result = build (resultcode, build_type, op0, op1);
2636 folded = fold (result);
2637 if (folded == result)
2638 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2639 if (final_type != 0)
2640 return convert (final_type, folded);
2645 /* Return a tree for the sum or difference (RESULTCODE says which)
2646 of pointer PTROP and integer INTOP. */
2649 pointer_int_sum (resultcode, ptrop, intop)
2650 enum tree_code resultcode;
2658 /* The result is a pointer of the same type that is being added. */
2660 tree result_type = TREE_TYPE (ptrop);
2662 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2664 if (pedantic || warn_pointer_arith)
2665 pedwarn ("pointer of type `void *' used in arithmetic");
2666 size_exp = integer_one_node;
2668 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2670 if (pedantic || warn_pointer_arith)
2671 pedwarn ("pointer to a function used in arithmetic");
2672 size_exp = integer_one_node;
2675 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2677 /* If what we are about to multiply by the size of the elements
2678 contains a constant term, apply distributive law
2679 and multiply that constant term separately.
2680 This helps produce common subexpressions. */
2682 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2683 && ! TREE_CONSTANT (intop)
2684 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2685 && TREE_CONSTANT (size_exp)
2686 /* If the constant comes from pointer subtraction,
2687 skip this optimization--it would cause an error. */
2688 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2689 /* If the constant is unsigned, and smaller than the pointer size,
2690 then we must skip this optimization. This is because it could cause
2691 an overflow error if the constant is negative but INTOP is not. */
2692 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2693 || (TYPE_PRECISION (TREE_TYPE (intop))
2694 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2696 enum tree_code subcode = resultcode;
2697 tree int_type = TREE_TYPE (intop);
2698 if (TREE_CODE (intop) == MINUS_EXPR)
2699 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2700 /* Convert both subexpression types to the type of intop,
2701 because weird cases involving pointer arithmetic
2702 can result in a sum or difference with different type args. */
2703 ptrop = build_binary_op (subcode, ptrop,
2704 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2705 intop = convert (int_type, TREE_OPERAND (intop, 0));
2708 /* Convert the integer argument to a type the same size as sizetype
2709 so the multiply won't overflow spuriously. */
2711 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2712 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2713 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2714 TREE_UNSIGNED (sizetype)), intop);
2716 /* Replace the integer argument with a suitable product by the object size.
2717 Do this multiplication as signed, then convert to the appropriate
2718 pointer type (actually unsigned integral). */
2720 intop = convert (result_type,
2721 build_binary_op (MULT_EXPR, intop,
2722 convert (TREE_TYPE (intop), size_exp), 1));
2724 /* Create the sum or difference. */
2726 result = build (resultcode, result_type, ptrop, intop);
2728 folded = fold (result);
2729 if (folded == result)
2730 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2734 /* Return a tree for the difference of pointers OP0 and OP1.
2735 The resulting tree has type int. */
2738 pointer_diff (op0, op1)
2741 tree result, folded;
2742 tree restype = ptrdiff_type_node;
2744 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2745 tree con0, con1, lit0, lit1;
2746 tree orig_op1 = op1;
2748 if (pedantic || warn_pointer_arith)
2750 if (TREE_CODE (target_type) == VOID_TYPE)
2751 pedwarn ("pointer of type `void *' used in subtraction");
2752 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2753 pedwarn ("pointer to a function used in subtraction");
2756 /* If the conversion to ptrdiff_type does anything like widening or
2757 converting a partial to an integral mode, we get a convert_expression
2758 that is in the way to do any simplifications.
2759 (fold-const.c doesn't know that the extra bits won't be needed.
2760 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2761 different mode in place.)
2762 So first try to find a common term here 'by hand'; we want to cover
2763 at least the cases that occur in legal static initializers. */
2764 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2765 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2767 if (TREE_CODE (con0) == PLUS_EXPR)
2769 lit0 = TREE_OPERAND (con0, 1);
2770 con0 = TREE_OPERAND (con0, 0);
2773 lit0 = integer_zero_node;
2775 if (TREE_CODE (con1) == PLUS_EXPR)
2777 lit1 = TREE_OPERAND (con1, 1);
2778 con1 = TREE_OPERAND (con1, 0);
2781 lit1 = integer_zero_node;
2783 if (operand_equal_p (con0, con1, 0))
2790 /* First do the subtraction as integers;
2791 then drop through to build the divide operator.
2792 Do not do default conversions on the minus operator
2793 in case restype is a short type. */
2795 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2796 convert (restype, op1), 0);
2797 /* This generates an error if op1 is pointer to incomplete type. */
2798 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2799 error ("arithmetic on pointer to an incomplete type");
2801 /* This generates an error if op0 is pointer to incomplete type. */
2802 op1 = c_size_in_bytes (target_type);
2804 /* Divide by the size, in easiest possible way. */
2806 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2808 folded = fold (result);
2809 if (folded == result)
2810 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2814 /* Construct and perhaps optimize a tree representation
2815 for a unary operation. CODE, a tree_code, specifies the operation
2816 and XARG is the operand.
2817 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2818 the default promotions (such as from short to int).
2819 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2820 allows non-lvalues; this is only used to handle conversion of non-lvalue
2821 arrays to pointers in C99. */
2824 build_unary_op (code, xarg, flag)
2825 enum tree_code code;
2829 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2832 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2834 int noconvert = flag;
2836 if (typecode == ERROR_MARK)
2837 return error_mark_node;
2838 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2839 typecode = INTEGER_TYPE;
2844 /* This is used for unary plus, because a CONVERT_EXPR
2845 is enough to prevent anybody from looking inside for
2846 associativity, but won't generate any code. */
2847 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2848 || typecode == COMPLEX_TYPE))
2850 error ("wrong type argument to unary plus");
2851 return error_mark_node;
2853 else if (!noconvert)
2854 arg = default_conversion (arg);
2858 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2859 || typecode == COMPLEX_TYPE))
2861 error ("wrong type argument to unary minus");
2862 return error_mark_node;
2864 else if (!noconvert)
2865 arg = default_conversion (arg);
2869 if (typecode == COMPLEX_TYPE)
2873 pedwarn ("ISO C does not support `~' for complex conjugation");
2875 arg = default_conversion (arg);
2877 else if (typecode != INTEGER_TYPE)
2879 error ("wrong type argument to bit-complement");
2880 return error_mark_node;
2882 else if (!noconvert)
2883 arg = default_conversion (arg);
2887 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2888 || typecode == COMPLEX_TYPE))
2890 error ("wrong type argument to abs");
2891 return error_mark_node;
2893 else if (!noconvert)
2894 arg = default_conversion (arg);
2898 /* Conjugating a real value is a no-op, but allow it anyway. */
2899 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2900 || typecode == COMPLEX_TYPE))
2902 error ("wrong type argument to conjugation");
2903 return error_mark_node;
2905 else if (!noconvert)
2906 arg = default_conversion (arg);
2909 case TRUTH_NOT_EXPR:
2910 if (typecode != INTEGER_TYPE
2911 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2912 && typecode != COMPLEX_TYPE
2913 /* These will convert to a pointer. */
2914 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2916 error ("wrong type argument to unary exclamation mark");
2917 return error_mark_node;
2919 arg = truthvalue_conversion (arg);
2920 return invert_truthvalue (arg);
2926 if (TREE_CODE (arg) == COMPLEX_CST)
2927 return TREE_REALPART (arg);
2928 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2929 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2934 if (TREE_CODE (arg) == COMPLEX_CST)
2935 return TREE_IMAGPART (arg);
2936 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2937 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2939 return convert (TREE_TYPE (arg), integer_zero_node);
2941 case PREINCREMENT_EXPR:
2942 case POSTINCREMENT_EXPR:
2943 case PREDECREMENT_EXPR:
2944 case POSTDECREMENT_EXPR:
2945 /* Handle complex lvalues (when permitted)
2946 by reduction to simpler cases. */
2948 val = unary_complex_lvalue (code, arg, 0);
2952 /* Increment or decrement the real part of the value,
2953 and don't change the imaginary part. */
2954 if (typecode == COMPLEX_TYPE)
2959 pedwarn ("ISO C does not support `++' and `--' on complex types");
2961 arg = stabilize_reference (arg);
2962 real = build_unary_op (REALPART_EXPR, arg, 1);
2963 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2964 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2965 build_unary_op (code, real, 1), imag);
2968 /* Report invalid types. */
2970 if (typecode != POINTER_TYPE
2971 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2973 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2974 error ("wrong type argument to increment");
2976 error ("wrong type argument to decrement");
2978 return error_mark_node;
2983 tree result_type = TREE_TYPE (arg);
2985 arg = get_unwidened (arg, 0);
2986 argtype = TREE_TYPE (arg);
2988 /* Compute the increment. */
2990 if (typecode == POINTER_TYPE)
2992 /* If pointer target is an undefined struct,
2993 we just cannot know how to do the arithmetic. */
2994 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2996 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2997 error ("increment of pointer to unknown structure");
2999 error ("decrement of pointer to unknown structure");
3001 else if ((pedantic || warn_pointer_arith)
3002 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
3003 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
3005 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3006 pedwarn ("wrong type argument to increment");
3008 pedwarn ("wrong type argument to decrement");
3011 inc = c_size_in_bytes (TREE_TYPE (result_type));
3014 inc = integer_one_node;
3016 inc = convert (argtype, inc);
3018 /* Handle incrementing a cast-expression. */
3021 switch (TREE_CODE (arg))
3026 case FIX_TRUNC_EXPR:
3027 case FIX_FLOOR_EXPR:
3028 case FIX_ROUND_EXPR:
3030 pedantic_lvalue_warning (CONVERT_EXPR);
3031 /* If the real type has the same machine representation
3032 as the type it is cast to, we can make better output
3033 by adding directly to the inside of the cast. */
3034 if ((TREE_CODE (TREE_TYPE (arg))
3035 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
3036 && (TYPE_MODE (TREE_TYPE (arg))
3037 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
3038 arg = TREE_OPERAND (arg, 0);
3041 tree incremented, modify, value;
3042 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3043 value = boolean_increment (code, arg);
3046 arg = stabilize_reference (arg);
3047 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3050 value = save_expr (arg);
3051 incremented = build (((code == PREINCREMENT_EXPR
3052 || code == POSTINCREMENT_EXPR)
3053 ? PLUS_EXPR : MINUS_EXPR),
3054 argtype, value, inc);
3055 TREE_SIDE_EFFECTS (incremented) = 1;
3056 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3057 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3059 TREE_USED (value) = 1;
3069 /* Complain about anything else that is not a true lvalue. */
3070 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3071 || code == POSTINCREMENT_EXPR)
3072 ? "invalid lvalue in increment"
3073 : "invalid lvalue in decrement")))
3074 return error_mark_node;
3076 /* Report a read-only lvalue. */
3077 if (TREE_READONLY (arg))
3078 readonly_warning (arg,
3079 ((code == PREINCREMENT_EXPR
3080 || code == POSTINCREMENT_EXPR)
3081 ? _("increment") : _("decrement")));
3083 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3084 val = boolean_increment (code, arg);
3086 val = build (code, TREE_TYPE (arg), arg, inc);
3087 TREE_SIDE_EFFECTS (val) = 1;
3088 val = convert (result_type, val);
3089 if (TREE_CODE (val) != code)
3090 TREE_NO_UNUSED_WARNING (val) = 1;
3095 /* Note that this operation never does default_conversion. */
3097 /* Let &* cancel out to simplify resulting code. */
3098 if (TREE_CODE (arg) == INDIRECT_REF)
3100 /* Don't let this be an lvalue. */
3101 if (lvalue_p (TREE_OPERAND (arg, 0)))
3102 return non_lvalue (TREE_OPERAND (arg, 0));
3103 return TREE_OPERAND (arg, 0);
3106 /* For &x[y], return x+y */
3107 if (TREE_CODE (arg) == ARRAY_REF)
3109 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3110 return error_mark_node;
3111 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3112 TREE_OPERAND (arg, 1), 1);
3115 /* Handle complex lvalues (when permitted)
3116 by reduction to simpler cases. */
3117 val = unary_complex_lvalue (code, arg, flag);
3121 #if 0 /* Turned off because inconsistent;
3122 float f; *&(int)f = 3.4 stores in int format
3123 whereas (int)f = 3.4 stores in float format. */
3124 /* Address of a cast is just a cast of the address
3125 of the operand of the cast. */
3126 switch (TREE_CODE (arg))
3131 case FIX_TRUNC_EXPR:
3132 case FIX_FLOOR_EXPR:
3133 case FIX_ROUND_EXPR:
3136 pedwarn ("ISO C forbids the address of a cast expression");
3137 return convert (build_pointer_type (TREE_TYPE (arg)),
3138 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3143 /* Anything not already handled and not a true memory reference
3144 or a non-lvalue array is an error. */
3145 else if (typecode != FUNCTION_TYPE && !flag
3146 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3147 return error_mark_node;
3149 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3150 argtype = TREE_TYPE (arg);
3152 /* If the lvalue is const or volatile, merge that into the type
3153 to which the address will point. Note that you can't get a
3154 restricted pointer by taking the address of something, so we
3155 only have to deal with `const' and `volatile' here. */
3156 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3157 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3158 argtype = c_build_type_variant (argtype,
3159 TREE_READONLY (arg),
3160 TREE_THIS_VOLATILE (arg));
3162 argtype = build_pointer_type (argtype);
3164 if (mark_addressable (arg) == 0)
3165 return error_mark_node;
3170 if (TREE_CODE (arg) == COMPONENT_REF)
3172 tree field = TREE_OPERAND (arg, 1);
3174 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
3176 if (DECL_C_BIT_FIELD (field))
3178 error ("attempt to take address of bit-field structure member `%s'",
3179 IDENTIFIER_POINTER (DECL_NAME (field)));
3180 return error_mark_node;
3183 addr = fold (build (PLUS_EXPR, argtype,
3184 convert (argtype, addr),
3185 convert (argtype, byte_position (field))));
3188 addr = build1 (code, argtype, arg);
3190 /* Address of a static or external variable or
3191 file-scope function counts as a constant. */
3193 && ! (TREE_CODE (arg) == FUNCTION_DECL
3194 && DECL_CONTEXT (arg) != 0))
3195 TREE_CONSTANT (addr) = 1;
3204 argtype = TREE_TYPE (arg);
3205 return fold (build1 (code, argtype, arg));
3209 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3210 convert ARG with the same conversions in the same order
3211 and return the result. */
3214 convert_sequence (conversions, arg)
3218 switch (TREE_CODE (conversions))
3223 case FIX_TRUNC_EXPR:
3224 case FIX_FLOOR_EXPR:
3225 case FIX_ROUND_EXPR:
3227 return convert (TREE_TYPE (conversions),
3228 convert_sequence (TREE_OPERAND (conversions, 0),
3237 /* Return nonzero if REF is an lvalue valid for this language.
3238 Lvalues can be assigned, unless their type has TYPE_READONLY.
3239 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3245 enum tree_code code = TREE_CODE (ref);
3252 return lvalue_p (TREE_OPERAND (ref, 0));
3254 case COMPOUND_LITERAL_EXPR:
3264 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3265 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3269 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3276 /* Return nonzero if REF is an lvalue valid for this language;
3277 otherwise, print an error message and return zero. */
3280 lvalue_or_else (ref, msgid)
3284 int win = lvalue_p (ref);
3287 error ("%s", msgid);
3292 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3293 for certain kinds of expressions which are not really lvalues
3294 but which we can accept as lvalues. If FLAG is nonzero, then
3295 non-lvalues are OK since we may be converting a non-lvalue array to
3298 If ARG is not a kind of expression we can handle, return zero. */
3301 unary_complex_lvalue (code, arg, flag)
3302 enum tree_code code;
3306 /* Handle (a, b) used as an "lvalue". */
3307 if (TREE_CODE (arg) == COMPOUND_EXPR)
3309 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3311 /* If this returns a function type, it isn't really being used as
3312 an lvalue, so don't issue a warning about it. */
3313 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3314 pedantic_lvalue_warning (COMPOUND_EXPR);
3316 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3317 TREE_OPERAND (arg, 0), real_result);
3320 /* Handle (a ? b : c) used as an "lvalue". */
3321 if (TREE_CODE (arg) == COND_EXPR)
3324 pedantic_lvalue_warning (COND_EXPR);
3325 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3326 pedantic_lvalue_warning (COMPOUND_EXPR);
3328 return (build_conditional_expr
3329 (TREE_OPERAND (arg, 0),
3330 build_unary_op (code, TREE_OPERAND (arg, 1), flag),
3331 build_unary_op (code, TREE_OPERAND (arg, 2), flag)));
3337 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3338 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3341 pedantic_lvalue_warning (code)
3342 enum tree_code code;
3348 pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3351 pedwarn ("ISO C forbids use of compound expressions as lvalues");
3354 pedwarn ("ISO C forbids use of cast expressions as lvalues");
3359 /* Warn about storing in something that is `const'. */
3362 readonly_warning (arg, msgid)
3366 if (TREE_CODE (arg) == COMPONENT_REF)
3368 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3369 readonly_warning (TREE_OPERAND (arg, 0), msgid);
3371 pedwarn ("%s of read-only member `%s'", _(msgid),
3372 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3374 else if (TREE_CODE (arg) == VAR_DECL)
3375 pedwarn ("%s of read-only variable `%s'", _(msgid),
3376 IDENTIFIER_POINTER (DECL_NAME (arg)));
3378 pedwarn ("%s of read-only location", _(msgid));
3381 /* Mark EXP saying that we need to be able to take the
3382 address of it; it should not be allocated in a register.
3383 Value is 1 if successful. */
3386 mark_addressable (exp)
3391 switch (TREE_CODE (x))
3394 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3396 error ("cannot take address of bitfield `%s'",
3397 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3401 /* ... fall through ... */
3407 x = TREE_OPERAND (x, 0);
3410 case COMPOUND_LITERAL_EXPR:
3412 TREE_ADDRESSABLE (x) = 1;
3419 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3420 && DECL_NONLOCAL (x))
3422 if (TREE_PUBLIC (x))
3424 error ("global register variable `%s' used in nested function",
3425 IDENTIFIER_POINTER (DECL_NAME (x)));
3428 pedwarn ("register variable `%s' used in nested function",
3429 IDENTIFIER_POINTER (DECL_NAME (x)));
3431 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3433 if (TREE_PUBLIC (x))
3435 error ("address of global register variable `%s' requested",
3436 IDENTIFIER_POINTER (DECL_NAME (x)));
3440 /* If we are making this addressable due to its having
3441 volatile components, give a different error message. Also
3442 handle the case of an unnamed parameter by not trying
3443 to give the name. */
3445 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3447 error ("cannot put object with volatile field into register");
3451 pedwarn ("address of register variable `%s' requested",
3452 IDENTIFIER_POINTER (DECL_NAME (x)));
3454 put_var_into_stack (x);
3458 TREE_ADDRESSABLE (x) = 1;
3459 #if 0 /* poplevel deals with this now. */
3460 if (DECL_CONTEXT (x) == 0)
3461 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3469 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3472 build_conditional_expr (ifexp, op1, op2)
3473 tree ifexp, op1, op2;
3477 enum tree_code code1;
3478 enum tree_code code2;
3479 tree result_type = NULL;
3480 tree orig_op1 = op1, orig_op2 = op2;
3482 ifexp = truthvalue_conversion (default_conversion (ifexp));
3484 #if 0 /* Produces wrong result if within sizeof. */
3485 /* Don't promote the operands separately if they promote
3486 the same way. Return the unpromoted type and let the combined
3487 value get promoted if necessary. */
3489 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3490 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3491 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3492 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3494 if (TREE_CODE (ifexp) == INTEGER_CST)
3495 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3497 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3501 /* Promote both alternatives. */
3503 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3504 op1 = default_conversion (op1);
3505 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3506 op2 = default_conversion (op2);
3508 if (TREE_CODE (ifexp) == ERROR_MARK
3509 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3510 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3511 return error_mark_node;
3513 type1 = TREE_TYPE (op1);
3514 code1 = TREE_CODE (type1);
3515 type2 = TREE_TYPE (op2);
3516 code2 = TREE_CODE (type2);
3518 /* Quickly detect the usual case where op1 and op2 have the same type
3520 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3523 result_type = type1;
3525 result_type = TYPE_MAIN_VARIANT (type1);
3527 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3528 || code1 == COMPLEX_TYPE)
3529 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3530 || code2 == COMPLEX_TYPE))
3532 result_type = common_type (type1, type2);
3534 /* If -Wsign-compare, warn here if type1 and type2 have
3535 different signedness. We'll promote the signed to unsigned
3536 and later code won't know it used to be different.
3537 Do this check on the original types, so that explicit casts
3538 will be considered, but default promotions won't. */
3539 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3540 && !skip_evaluation)
3542 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3543 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3545 if (unsigned_op1 ^ unsigned_op2)
3547 /* Do not warn if the result type is signed, since the
3548 signed type will only be chosen if it can represent
3549 all the values of the unsigned type. */
3550 if (! TREE_UNSIGNED (result_type))
3552 /* Do not warn if the signed quantity is an unsuffixed
3553 integer literal (or some static constant expression
3554 involving such literals) and it is non-negative. */
3555 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3556 || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3559 warning ("signed and unsigned type in conditional expression");
3563 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3565 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3566 pedwarn ("ISO C forbids conditional expr with only one void side");
3567 result_type = void_type_node;
3569 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3571 if (comp_target_types (type1, type2))
3572 result_type = common_type (type1, type2);
3573 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3574 && TREE_CODE (orig_op1) != NOP_EXPR)
3575 result_type = qualify_type (type2, type1);
3576 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3577 && TREE_CODE (orig_op2) != NOP_EXPR)
3578 result_type = qualify_type (type1, type2);
3579 else if (VOID_TYPE_P (TREE_TYPE (type1)))
3581 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3582 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3583 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3584 TREE_TYPE (type2)));
3586 else if (VOID_TYPE_P (TREE_TYPE (type2)))
3588 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3589 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3590 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3591 TREE_TYPE (type1)));
3595 pedwarn ("pointer type mismatch in conditional expression");
3596 result_type = build_pointer_type (void_type_node);
3599 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3601 if (! integer_zerop (op2))
3602 pedwarn ("pointer/integer type mismatch in conditional expression");
3605 op2 = null_pointer_node;
3607 result_type = type1;
3609 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3611 if (!integer_zerop (op1))
3612 pedwarn ("pointer/integer type mismatch in conditional expression");
3615 op1 = null_pointer_node;
3617 result_type = type2;
3622 if (flag_cond_mismatch)
3623 result_type = void_type_node;
3626 error ("type mismatch in conditional expression");
3627 return error_mark_node;
3631 /* Merge const and volatile flags of the incoming types. */
3633 = build_type_variant (result_type,
3634 TREE_READONLY (op1) || TREE_READONLY (op2),
3635 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3637 if (result_type != TREE_TYPE (op1))
3638 op1 = convert_and_check (result_type, op1);
3639 if (result_type != TREE_TYPE (op2))
3640 op2 = convert_and_check (result_type, op2);
3642 if (TREE_CODE (ifexp) == INTEGER_CST)
3643 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3645 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3648 /* Given a list of expressions, return a compound expression
3649 that performs them all and returns the value of the last of them. */
3652 build_compound_expr (list)
3655 return internal_build_compound_expr (list, TRUE);
3659 internal_build_compound_expr (list, first_p)
3665 if (TREE_CHAIN (list) == 0)
3667 /* Convert arrays and functions to pointers when there
3668 really is a comma operator. */
3671 = default_function_array_conversion (TREE_VALUE (list));
3673 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3674 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3676 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3677 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3678 list = TREE_OPERAND (list, 0);
3681 /* Don't let (0, 0) be null pointer constant. */
3682 if (!first_p && integer_zerop (TREE_VALUE (list)))
3683 return non_lvalue (TREE_VALUE (list));
3684 return TREE_VALUE (list);
3687 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3689 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3691 /* The left-hand operand of a comma expression is like an expression
3692 statement: with -W or -Wunused, we should warn if it doesn't have
3693 any side-effects, unless it was explicitly cast to (void). */
3694 if ((extra_warnings || warn_unused_value)
3695 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3696 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3697 warning ("left-hand operand of comma expression has no effect");
3699 /* When pedantic, a compound expression can be neither an lvalue
3700 nor an integer constant expression. */
3705 /* With -Wunused, we should also warn if the left-hand operand does have
3706 side-effects, but computes a value which is not used. For example, in
3707 `foo() + bar(), baz()' the result of the `+' operator is not used,
3708 so we should issue a warning. */
3709 else if (warn_unused_value)
3710 warn_if_unused_value (TREE_VALUE (list));
3712 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3715 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3718 build_c_cast (type, expr)
3724 if (type == error_mark_node || expr == error_mark_node)
3725 return error_mark_node;
3726 type = TYPE_MAIN_VARIANT (type);
3729 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3730 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3731 value = TREE_OPERAND (value, 0);
3734 if (TREE_CODE (type) == ARRAY_TYPE)
3736 error ("cast specifies array type");
3737 return error_mark_node;
3740 if (TREE_CODE (type) == FUNCTION_TYPE)
3742 error ("cast specifies function type");
3743 return error_mark_node;
3746 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3750 if (TREE_CODE (type) == RECORD_TYPE
3751 || TREE_CODE (type) == UNION_TYPE)
3752 pedwarn ("ISO C forbids casting nonscalar to the same type");
3755 else if (TREE_CODE (type) == UNION_TYPE)
3758 value = default_function_array_conversion (value);
3760 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3761 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3762 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3771 pedwarn ("ISO C forbids casts to union type");
3772 if (TYPE_NAME (type) != 0)
3774 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3775 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3777 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3781 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3782 build_tree_list (field, value)),
3784 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3787 error ("cast to union type from type not present in union");
3788 return error_mark_node;
3794 /* If casting to void, avoid the error that would come
3795 from default_conversion in the case of a non-lvalue array. */
3796 if (type == void_type_node)
3797 return build1 (CONVERT_EXPR, type, value);
3799 /* Convert functions and arrays to pointers,
3800 but don't convert any other types. */
3801 value = default_function_array_conversion (value);
3802 otype = TREE_TYPE (value);
3804 /* Optionally warn about potentially worrisome casts. */
3807 && TREE_CODE (type) == POINTER_TYPE
3808 && TREE_CODE (otype) == POINTER_TYPE)
3810 tree in_type = type;
3811 tree in_otype = otype;
3814 /* Check that the qualifiers on IN_TYPE are a superset of
3815 the qualifiers of IN_OTYPE. The outermost level of
3816 POINTER_TYPE nodes is uninteresting and we stop as soon
3817 as we hit a non-POINTER_TYPE node on either type. */
3820 in_otype = TREE_TYPE (in_otype);
3821 in_type = TREE_TYPE (in_type);
3822 warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3824 while (TREE_CODE (in_type) == POINTER_TYPE
3825 && TREE_CODE (in_otype) == POINTER_TYPE);
3828 /* There are qualifiers present in IN_OTYPE that are not
3829 present in IN_TYPE. */
3830 warning ("cast discards qualifiers from pointer target type");
3833 /* Warn about possible alignment problems. */
3834 if (STRICT_ALIGNMENT && warn_cast_align
3835 && TREE_CODE (type) == POINTER_TYPE
3836 && TREE_CODE (otype) == POINTER_TYPE
3837 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3838 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3839 /* Don't warn about opaque types, where the actual alignment
3840 restriction is unknown. */
3841 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3842 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3843 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3844 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3845 warning ("cast increases required alignment of target type");
3847 if (TREE_CODE (type) == INTEGER_TYPE
3848 && TREE_CODE (otype) == POINTER_TYPE
3849 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3850 && !TREE_CONSTANT (value))
3851 warning ("cast from pointer to integer of different size");
3853 if (warn_bad_function_cast
3854 && TREE_CODE (value) == CALL_EXPR
3855 && TREE_CODE (type) != TREE_CODE (otype))
3856 warning ("cast does not match function type");
3858 if (TREE_CODE (type) == POINTER_TYPE
3859 && TREE_CODE (otype) == INTEGER_TYPE
3860 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3861 /* Don't warn about converting any constant. */
3862 && !TREE_CONSTANT (value))
3863 warning ("cast to pointer from integer of different size");
3866 value = convert (type, value);
3868 /* Ignore any integer overflow caused by the cast. */
3869 if (TREE_CODE (value) == INTEGER_CST)
3871 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3872 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3876 /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant. */
3877 if (pedantic && TREE_CODE (value) == INTEGER_CST
3878 && TREE_CODE (expr) == INTEGER_CST
3879 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3880 value = non_lvalue (value);
3882 /* If pedantic, don't let a cast be an lvalue. */
3883 if (value == expr && pedantic)
3884 value = non_lvalue (value);
3889 /* Interpret a cast of expression EXPR to type TYPE. */
3891 c_cast_expr (type, expr)
3894 int saved_wsp = warn_strict_prototypes;
3896 /* This avoids warnings about unprototyped casts on
3897 integers. E.g. "#define SIG_DFL (void(*)())0". */
3898 if (TREE_CODE (expr) == INTEGER_CST)
3899 warn_strict_prototypes = 0;
3900 type = groktypename (type);
3901 warn_strict_prototypes = saved_wsp;
3903 return build_c_cast (type, expr);
3907 /* Build an assignment expression of lvalue LHS from value RHS.
3908 MODIFYCODE is the code for a binary operator that we use
3909 to combine the old value of LHS with RHS to get the new value.
3910 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3913 build_modify_expr (lhs, modifycode, rhs)
3915 enum tree_code modifycode;
3919 tree lhstype = TREE_TYPE (lhs);
3920 tree olhstype = lhstype;
3922 /* Types that aren't fully specified cannot be used in assignments. */
3923 lhs = require_complete_type (lhs);
3925 /* Avoid duplicate error messages from operands that had errors. */
3926 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3927 return error_mark_node;
3929 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3930 /* Do not use STRIP_NOPS here. We do not want an enumerator
3931 whose value is 0 to count as a null pointer constant. */
3932 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3933 rhs = TREE_OPERAND (rhs, 0);
3937 /* Handle control structure constructs used as "lvalues". */
3939 switch (TREE_CODE (lhs))
3941 /* Handle (a, b) used as an "lvalue". */
3943 pedantic_lvalue_warning (COMPOUND_EXPR);
3944 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3945 if (TREE_CODE (newrhs) == ERROR_MARK)
3946 return error_mark_node;
3947 return build (COMPOUND_EXPR, lhstype,
3948 TREE_OPERAND (lhs, 0), newrhs);
3950 /* Handle (a ? b : c) used as an "lvalue". */
3952 pedantic_lvalue_warning (COND_EXPR);
3953 rhs = save_expr (rhs);
3955 /* Produce (a ? (b = rhs) : (c = rhs))
3956 except that the RHS goes through a save-expr
3957 so the code to compute it is only emitted once. */
3959 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3960 build_modify_expr (TREE_OPERAND (lhs, 1),
3962 build_modify_expr (TREE_OPERAND (lhs, 2),
3964 if (TREE_CODE (cond) == ERROR_MARK)
3966 /* Make sure the code to compute the rhs comes out
3967 before the split. */
3968 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3969 /* But cast it to void to avoid an "unused" error. */
3970 convert (void_type_node, rhs), cond);
3976 /* If a binary op has been requested, combine the old LHS value with the RHS
3977 producing the value we should actually store into the LHS. */
3979 if (modifycode != NOP_EXPR)
3981 lhs = stabilize_reference (lhs);
3982 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3985 /* Handle a cast used as an "lvalue".
3986 We have already performed any binary operator using the value as cast.
3987 Now convert the result to the cast type of the lhs,
3988 and then true type of the lhs and store it there;
3989 then convert result back to the cast type to be the value
3990 of the assignment. */
3992 switch (TREE_CODE (lhs))
3997 case FIX_TRUNC_EXPR:
3998 case FIX_FLOOR_EXPR:
3999 case FIX_ROUND_EXPR:
4001 newrhs = default_function_array_conversion (newrhs);
4003 tree inner_lhs = TREE_OPERAND (lhs, 0);
4005 result = build_modify_expr (inner_lhs, NOP_EXPR,
4006 convert (TREE_TYPE (inner_lhs),
4007 convert (lhstype, newrhs)));
4008 if (TREE_CODE (result) == ERROR_MARK)
4010 pedantic_lvalue_warning (CONVERT_EXPR);
4011 return convert (TREE_TYPE (lhs), result);
4018 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
4019 Reject anything strange now. */
4021 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
4022 return error_mark_node;
4024 /* Warn about storing in something that is `const'. */
4026 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
4027 || ((TREE_CODE (lhstype) == RECORD_TYPE
4028 || TREE_CODE (lhstype) == UNION_TYPE)
4029 && C_TYPE_FIELDS_READONLY (lhstype)))
4030 readonly_warning (lhs, "assignment");
4032 /* If storing into a structure or union member,
4033 it has probably been given type `int'.
4034 Compute the type that would go with
4035 the actual amount of storage the member occupies. */
4037 if (TREE_CODE (lhs) == COMPONENT_REF
4038 && (TREE_CODE (lhstype) == INTEGER_TYPE
4039 || TREE_CODE (lhstype) == BOOLEAN_TYPE
4040 || TREE_CODE (lhstype) == REAL_TYPE
4041 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4042 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4044 /* If storing in a field that is in actuality a short or narrower than one,
4045 we must store in the field in its actual type. */
4047 if (lhstype != TREE_TYPE (lhs))
4049 lhs = copy_node (lhs);
4050 TREE_TYPE (lhs) = lhstype;
4053 /* Convert new value to destination type. */
4055 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4056 NULL_TREE, NULL_TREE, 0);
4057 if (TREE_CODE (newrhs) == ERROR_MARK)
4058 return error_mark_node;
4062 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4063 TREE_SIDE_EFFECTS (result) = 1;
4065 /* If we got the LHS in a different type for storing in,
4066 convert the result back to the nominal type of LHS
4067 so that the value we return always has the same type
4068 as the LHS argument. */
4070 if (olhstype == TREE_TYPE (result))
4072 return convert_for_assignment (olhstype, result, _("assignment"),
4073 NULL_TREE, NULL_TREE, 0);
4076 /* Convert value RHS to type TYPE as preparation for an assignment
4077 to an lvalue of type TYPE.
4078 The real work of conversion is done by `convert'.
4079 The purpose of this function is to generate error messages
4080 for assignments that are not allowed in C.
4081 ERRTYPE is a string to use in error messages:
4082 "assignment", "return", etc. If it is null, this is parameter passing
4083 for a function call (and different error messages are output).
4085 FUNNAME is the name of the function being called,
4086 as an IDENTIFIER_NODE, or null.
4087 PARMNUM is the number of the argument, for printing in error messages. */
4090 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4092 const char *errtype;
4093 tree fundecl, funname;
4096 enum tree_code codel = TREE_CODE (type);
4098 enum tree_code coder;
4100 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4101 /* Do not use STRIP_NOPS here. We do not want an enumerator
4102 whose value is 0 to count as a null pointer constant. */
4103 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4104 rhs = TREE_OPERAND (rhs, 0);
4106 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4107 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4108 rhs = default_conversion (rhs);
4109 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4110 rhs = decl_constant_value_for_broken_optimization (rhs);
4112 rhstype = TREE_TYPE (rhs);
4113 coder = TREE_CODE (rhstype);
4115 if (coder == ERROR_MARK)
4116 return error_mark_node;
4118 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4120 overflow_warning (rhs);
4121 /* Check for Objective-C protocols. This will issue a warning if
4122 there are protocol violations. No need to use the return value. */
4123 maybe_objc_comptypes (type, rhstype, 0);
4127 if (coder == VOID_TYPE)
4129 error ("void value not ignored as it ought to be");
4130 return error_mark_node;
4132 /* A type converts to a reference to it.
4133 This code doesn't fully support references, it's just for the
4134 special case of va_start and va_copy. */
4135 if (codel == REFERENCE_TYPE
4136 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4138 if (mark_addressable (rhs) == 0)
4139 return error_mark_node;
4140 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4142 /* We already know that these two types are compatible, but they
4143 may not be exactly identical. In fact, `TREE_TYPE (type)' is
4144 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4145 likely to be va_list, a typedef to __builtin_va_list, which
4146 is different enough that it will cause problems later. */
4147 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4148 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4150 rhs = build1 (NOP_EXPR, type, rhs);
4153 /* Arithmetic types all interconvert, and enum is treated like int. */
4154 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4155 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4156 || codel == BOOLEAN_TYPE)
4157 && (coder == INTEGER_TYPE || coder == REAL_TYPE
4158 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4159 || coder == BOOLEAN_TYPE))
4160 return convert_and_check (type, rhs);
4162 /* Conversion to a transparent union from its member types.
4163 This applies only to function arguments. */
4164 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4167 tree marginal_memb_type = 0;
4169 for (memb_types = TYPE_FIELDS (type); memb_types;
4170 memb_types = TREE_CHAIN (memb_types))
4172 tree memb_type = TREE_TYPE (memb_types);
4174 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4175 TYPE_MAIN_VARIANT (rhstype)))
4178 if (TREE_CODE (memb_type) != POINTER_TYPE)
4181 if (coder == POINTER_TYPE)
4183 tree ttl = TREE_TYPE (memb_type);
4184 tree ttr = TREE_TYPE (rhstype);
4186 /* Any non-function converts to a [const][volatile] void *
4187 and vice versa; otherwise, targets must be the same.
4188 Meanwhile, the lhs target must have all the qualifiers of
4190 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4191 || comp_target_types (memb_type, rhstype))
4193 /* If this type won't generate any warnings, use it. */
4194 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4195 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4196 && TREE_CODE (ttl) == FUNCTION_TYPE)
4197 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4198 == TYPE_QUALS (ttr))
4199 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4200 == TYPE_QUALS (ttl))))
4203 /* Keep looking for a better type, but remember this one. */
4204 if (! marginal_memb_type)
4205 marginal_memb_type = memb_type;
4209 /* Can convert integer zero to any pointer type. */
4210 if (integer_zerop (rhs)
4211 || (TREE_CODE (rhs) == NOP_EXPR
4212 && integer_zerop (TREE_OPERAND (rhs, 0))))
4214 rhs = null_pointer_node;
4219 if (memb_types || marginal_memb_type)
4223 /* We have only a marginally acceptable member type;
4224 it needs a warning. */
4225 tree ttl = TREE_TYPE (marginal_memb_type);
4226 tree ttr = TREE_TYPE (rhstype);
4228 /* Const and volatile mean something different for function
4229 types, so the usual warnings are not appropriate. */
4230 if (TREE_CODE (ttr) == FUNCTION_TYPE
4231 && TREE_CODE (ttl) == FUNCTION_TYPE)
4233 /* Because const and volatile on functions are
4234 restrictions that say the function will not do
4235 certain things, it is okay to use a const or volatile
4236 function where an ordinary one is wanted, but not
4238 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4239 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4240 errtype, funname, parmnum);
4242 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4243 warn_for_assignment ("%s discards qualifiers from pointer target type",
4248 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4249 pedwarn ("ISO C prohibits argument conversion to union type");
4251 return build1 (NOP_EXPR, type, rhs);
4255 /* Conversions among pointers */
4256 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4257 && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4259 tree ttl = TREE_TYPE (type);
4260 tree ttr = TREE_TYPE (rhstype);
4262 /* Any non-function converts to a [const][volatile] void *
4263 and vice versa; otherwise, targets must be the same.
4264 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4265 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4266 || comp_target_types (type, rhstype)
4267 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4268 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4271 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4274 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4275 which are not ANSI null ptr constants. */
4276 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4277 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4278 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4279 errtype, funname, parmnum);
4280 /* Const and volatile mean something different for function types,
4281 so the usual warnings are not appropriate. */
4282 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4283 && TREE_CODE (ttl) != FUNCTION_TYPE)
4285 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4286 warn_for_assignment ("%s discards qualifiers from pointer target type",
4287 errtype, funname, parmnum);
4288 /* If this is not a case of ignoring a mismatch in signedness,
4290 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4291 || comp_target_types (type, rhstype))
4293 /* If there is a mismatch, do warn. */
4295 warn_for_assignment ("pointer targets in %s differ in signedness",
4296 errtype, funname, parmnum);
4298 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4299 && TREE_CODE (ttr) == FUNCTION_TYPE)
4301 /* Because const and volatile on functions are restrictions
4302 that say the function will not do certain things,
4303 it is okay to use a const or volatile function
4304 where an ordinary one is wanted, but not vice-versa. */
4305 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4306 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4307 errtype, funname, parmnum);
4311 warn_for_assignment ("%s from incompatible pointer type",
4312 errtype, funname, parmnum);
4313 return convert (type, rhs);
4315 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4317 /* An explicit constant 0 can convert to a pointer,
4318 or one that results from arithmetic, even including
4319 a cast to integer type. */
4320 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4322 ! (TREE_CODE (rhs) == NOP_EXPR
4323 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4324 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4325 && integer_zerop (TREE_OPERAND (rhs, 0))))
4327 warn_for_assignment ("%s makes pointer from integer without a cast",
4328 errtype, funname, parmnum);
4329 return convert (type, rhs);
4331 return null_pointer_node;
4333 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4335 warn_for_assignment ("%s makes integer from pointer without a cast",
4336 errtype, funname, parmnum);
4337 return convert (type, rhs);
4339 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4340 return convert (type, rhs);
4346 tree selector = maybe_building_objc_message_expr ();
4348 if (selector && parmnum > 2)
4349 error ("incompatible type for argument %d of `%s'",
4350 parmnum - 2, IDENTIFIER_POINTER (selector));
4352 error ("incompatible type for argument %d of `%s'",
4353 parmnum, IDENTIFIER_POINTER (funname));
4356 error ("incompatible type for argument %d of indirect function call",
4360 error ("incompatible types in %s", errtype);
4362 return error_mark_node;
4365 /* Print a warning using MSGID.
4366 It gets OPNAME as its one parameter.
4367 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4368 FUNCTION and ARGNUM are handled specially if we are building an
4369 Objective-C selector. */
4372 warn_for_assignment (msgid, opname, function, argnum)
4380 tree selector = maybe_building_objc_message_expr ();
4383 if (selector && argnum > 2)
4385 function = selector;
4390 /* Function name is known; supply it. */
4391 const char *const argstring = _("passing arg %d of `%s'");
4392 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4393 + strlen (argstring) + 1 + 25
4395 sprintf (new_opname, argstring, argnum,
4396 IDENTIFIER_POINTER (function));
4400 /* Function name unknown (call through ptr); just give arg number.*/
4401 const char *const argnofun = _("passing arg %d of pointer to function");
4402 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4403 sprintf (new_opname, argnofun, argnum);
4405 opname = new_opname;
4407 pedwarn (msgid, opname);
4410 /* If VALUE is a compound expr all of whose expressions are constant, then
4411 return its value. Otherwise, return error_mark_node.
4413 This is for handling COMPOUND_EXPRs as initializer elements
4414 which is allowed with a warning when -pedantic is specified. */
4417 valid_compound_expr_initializer (value, endtype)
4421 if (TREE_CODE (value) == COMPOUND_EXPR)
4423 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4425 return error_mark_node;
4426 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4429 else if (! TREE_CONSTANT (value)
4430 && ! initializer_constant_valid_p (value, endtype))
4431 return error_mark_node;
4436 /* Perform appropriate conversions on the initial value of a variable,
4437 store it in the declaration DECL,
4438 and print any error messages that are appropriate.
4439 If the init is invalid, store an ERROR_MARK. */
4442 store_init_value (decl, init)
4447 /* If variable's type was invalidly declared, just ignore it. */
4449 type = TREE_TYPE (decl);
4450 if (TREE_CODE (type) == ERROR_MARK)
4453 /* Digest the specified initializer into an expression. */
4455 value = digest_init (type, init, TREE_STATIC (decl),
4456 TREE_STATIC (decl) || (pedantic && !flag_isoc99));
4458 /* Store the expression if valid; else report error. */
4461 /* Note that this is the only place we can detect the error
4462 in a case such as struct foo bar = (struct foo) { x, y };
4463 where there is one initial value which is a constructor expression. */
4464 if (value == error_mark_node)
4466 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4468 error ("initializer for static variable is not constant");
4469 value = error_mark_node;
4471 else if (TREE_STATIC (decl)
4472 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4474 error ("initializer for static variable uses complicated arithmetic");
4475 value = error_mark_node;
4479 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4481 if (! TREE_CONSTANT (value))
4482 pedwarn ("aggregate initializer is not constant");
4483 else if (! TREE_STATIC (value))
4484 pedwarn ("aggregate initializer uses complicated arithmetic");
4489 if (warn_traditional && !in_system_header
4490 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4491 warning ("traditional C rejects automatic aggregate initialization");
4493 DECL_INITIAL (decl) = value;
4495 /* ANSI wants warnings about out-of-range constant initializers. */
4496 STRIP_TYPE_NOPS (value);
4497 constant_expression_warning (value);
4500 /* Methods for storing and printing names for error messages. */
4502 /* Implement a spelling stack that allows components of a name to be pushed
4503 and popped. Each element on the stack is this structure. */
4515 #define SPELLING_STRING 1
4516 #define SPELLING_MEMBER 2
4517 #define SPELLING_BOUNDS 3
4519 static struct spelling *spelling; /* Next stack element (unused). */
4520 static struct spelling *spelling_base; /* Spelling stack base. */
4521 static int spelling_size; /* Size of the spelling stack. */
4523 /* Macros to save and restore the spelling stack around push_... functions.
4524 Alternative to SAVE_SPELLING_STACK. */
4526 #define SPELLING_DEPTH() (spelling - spelling_base)
4527 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4529 /* Save and restore the spelling stack around arbitrary C code. */
4531 #define SAVE_SPELLING_DEPTH(code) \
4533 int __depth = SPELLING_DEPTH (); \
4535 RESTORE_SPELLING_DEPTH (__depth); \
4538 /* Push an element on the spelling stack with type KIND and assign VALUE
4541 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4543 int depth = SPELLING_DEPTH (); \
4545 if (depth >= spelling_size) \
4547 spelling_size += 10; \
4548 if (spelling_base == 0) \
4550 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4553 = (struct spelling *) xrealloc (spelling_base, \
4554 spelling_size * sizeof (struct spelling)); \
4555 RESTORE_SPELLING_DEPTH (depth); \
4558 spelling->kind = (KIND); \
4559 spelling->MEMBER = (VALUE); \
4563 /* Push STRING on the stack. Printed literally. */
4566 push_string (string)
4569 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4572 /* Push a member name on the stack. Printed as '.' STRING. */
4575 push_member_name (decl)
4579 const char *const string
4580 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4581 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4584 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4587 push_array_bounds (bounds)
4590 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4593 /* Compute the maximum size in bytes of the printed spelling. */
4601 for (p = spelling_base; p < spelling; p++)
4603 if (p->kind == SPELLING_BOUNDS)
4606 size += strlen (p->u.s) + 1;
4612 /* Print the spelling to BUFFER and return it. */
4615 print_spelling (buffer)
4621 for (p = spelling_base; p < spelling; p++)
4622 if (p->kind == SPELLING_BOUNDS)
4624 sprintf (d, "[%d]", p->u.i);
4630 if (p->kind == SPELLING_MEMBER)
4632 for (s = p->u.s; (*d = *s++); d++)
4639 /* Issue an error message for a bad initializer component.
4640 MSGID identifies the message.
4641 The component name is taken from the spelling stack. */
4649 error ("%s", msgid);
4650 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4652 error ("(near initialization for `%s')", ofwhat);
4655 /* Issue a pedantic warning for a bad initializer component.
4656 MSGID identifies the message.
4657 The component name is taken from the spelling stack. */
4660 pedwarn_init (msgid)
4665 pedwarn ("%s", msgid);
4666 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4668 pedwarn ("(near initialization for `%s')", ofwhat);
4671 /* Issue a warning for a bad initializer component.
4672 MSGID identifies the message.
4673 The component name is taken from the spelling stack. */
4676 warning_init (msgid)
4681 warning ("%s", msgid);
4682 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4684 warning ("(near initialization for `%s')", ofwhat);
4687 /* Digest the parser output INIT as an initializer for type TYPE.
4688 Return a C expression of type TYPE to represent the initial value.
4690 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4691 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4692 applies only to elements of constructors. */
4695 digest_init (type, init, require_constant, constructor_constant)
4697 int require_constant, constructor_constant;
4699 enum tree_code code = TREE_CODE (type);
4700 tree inside_init = init;
4702 if (type == error_mark_node
4703 || init == error_mark_node
4704 || TREE_TYPE (init) == error_mark_node)
4705 return error_mark_node;
4707 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4708 /* Do not use STRIP_NOPS here. We do not want an enumerator
4709 whose value is 0 to count as a null pointer constant. */
4710 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4711 inside_init = TREE_OPERAND (init, 0);
4713 inside_init = fold (inside_init);
4715 /* Initialization of an array of chars from a string constant
4716 optionally enclosed in braces. */
4718 if (code == ARRAY_TYPE)
4720 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4721 if ((typ1 == char_type_node
4722 || typ1 == signed_char_type_node
4723 || typ1 == unsigned_char_type_node
4724 || typ1 == unsigned_wchar_type_node
4725 || typ1 == signed_wchar_type_node)
4726 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4728 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4729 TYPE_MAIN_VARIANT (type)))
4732 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4734 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4736 error_init ("char-array initialized from wide string");
4737 return error_mark_node;
4739 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4741 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4743 error_init ("int-array initialized from non-wide string");
4744 return error_mark_node;
4747 TREE_TYPE (inside_init) = type;
4748 if (TYPE_DOMAIN (type) != 0
4749 && TYPE_SIZE (type) != 0
4750 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4751 /* Subtract 1 (or sizeof (wchar_t))
4752 because it's ok to ignore the terminating null char
4753 that is counted in the length of the constant. */
4754 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4755 TREE_STRING_LENGTH (inside_init)
4756 - ((TYPE_PRECISION (typ1)
4757 != TYPE_PRECISION (char_type_node))
4758 ? (TYPE_PRECISION (wchar_type_node)
4761 pedwarn_init ("initializer-string for array of chars is too long");
4767 /* Any type can be initialized
4768 from an expression of the same type, optionally with braces. */
4770 if (inside_init && TREE_TYPE (inside_init) != 0
4771 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4772 TYPE_MAIN_VARIANT (type))
4773 || (code == ARRAY_TYPE
4774 && comptypes (TREE_TYPE (inside_init), type))
4775 || (code == POINTER_TYPE
4776 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4777 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4778 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4779 TREE_TYPE (type)))))
4781 if (code == POINTER_TYPE)
4782 inside_init = default_function_array_conversion (inside_init);
4784 if (require_constant && !flag_isoc99
4785 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4787 /* As an extension, allow initializing objects with static storage
4788 duration with compound literals (which are then treated just as
4789 the brace enclosed list they contain). */
4790 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4791 inside_init = DECL_INITIAL (decl);
4794 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4795 && TREE_CODE (inside_init) != CONSTRUCTOR)
4797 error_init ("array initialized from non-constant array expression");
4798 return error_mark_node;
4801 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4802 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4804 /* Compound expressions can only occur here if -pedantic or
4805 -pedantic-errors is specified. In the later case, we always want
4806 an error. In the former case, we simply want a warning. */
4807 if (require_constant && pedantic
4808 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4811 = valid_compound_expr_initializer (inside_init,
4812 TREE_TYPE (inside_init));
4813 if (inside_init == error_mark_node)
4814 error_init ("initializer element is not constant");
4816 pedwarn_init ("initializer element is not constant");
4817 if (flag_pedantic_errors)
4818 inside_init = error_mark_node;
4820 else if (require_constant
4821 && (!TREE_CONSTANT (inside_init)
4822 /* This test catches things like `7 / 0' which
4823 result in an expression for which TREE_CONSTANT
4824 is true, but which is not actually something
4825 that is a legal constant. We really should not
4826 be using this function, because it is a part of
4827 the back-end. Instead, the expression should
4828 already have been turned into ERROR_MARK_NODE. */
4829 || !initializer_constant_valid_p (inside_init,
4830 TREE_TYPE (inside_init))))
4832 error_init ("initializer element is not constant");
4833 inside_init = error_mark_node;
4839 /* Handle scalar types, including conversions. */
4841 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4842 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4844 /* Note that convert_for_assignment calls default_conversion
4845 for arrays and functions. We must not call it in the
4846 case where inside_init is a null pointer constant. */
4848 = convert_for_assignment (type, init, _("initialization"),
4849 NULL_TREE, NULL_TREE, 0);
4851 if (require_constant && ! TREE_CONSTANT (inside_init))
4853 error_init ("initializer element is not constant");
4854 inside_init = error_mark_node;
4856 else if (require_constant
4857 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4859 error_init ("initializer element is not computable at load time");
4860 inside_init = error_mark_node;
4866 /* Come here only for records and arrays. */
4868 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4870 error_init ("variable-sized object may not be initialized");
4871 return error_mark_node;
4874 /* Traditionally, you can write struct foo x = 0;
4875 and it initializes the first element of x to 0. */
4876 if (flag_traditional)
4878 tree top = 0, prev = 0, otype = type;
4879 while (TREE_CODE (type) == RECORD_TYPE
4880 || TREE_CODE (type) == ARRAY_TYPE
4881 || TREE_CODE (type) == QUAL_UNION_TYPE
4882 || TREE_CODE (type) == UNION_TYPE)
4884 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4888 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4890 if (TREE_CODE (type) == ARRAY_TYPE)
4891 type = TREE_TYPE (type);
4892 else if (TYPE_FIELDS (type))
4893 type = TREE_TYPE (TYPE_FIELDS (type));
4896 error_init ("invalid initializer");
4897 return error_mark_node;
4903 TREE_OPERAND (prev, 1)
4904 = build_tree_list (NULL_TREE,
4905 digest_init (type, init, require_constant,
4906 constructor_constant));
4910 return error_mark_node;
4912 error_init ("invalid initializer");
4913 return error_mark_node;
4916 /* Handle initializers that use braces. */
4918 /* Type of object we are accumulating a constructor for.
4919 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4920 static tree constructor_type;
4922 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4924 static tree constructor_fields;
4926 /* For an ARRAY_TYPE, this is the specified index
4927 at which to store the next element we get. */
4928 static tree constructor_index;
4930 /* For an ARRAY_TYPE, this is the maximum index. */
4931 static tree constructor_max_index;
4933 /* For a RECORD_TYPE, this is the first field not yet written out. */
4934 static tree constructor_unfilled_fields;
4936 /* For an ARRAY_TYPE, this is the index of the first element
4937 not yet written out. */
4938 static tree constructor_unfilled_index;
4940 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4941 This is so we can generate gaps between fields, when appropriate. */
4942 static tree constructor_bit_index;
4944 /* If we are saving up the elements rather than allocating them,
4945 this is the list of elements so far (in reverse order,
4946 most recent first). */
4947 static tree constructor_elements;
4949 /* 1 if constructor should be incrementally stored into a constructor chain,
4950 0 if all the elements should be kept in AVL tree. */
4951 static int constructor_incremental;
4953 /* 1 if so far this constructor's elements are all compile-time constants. */
4954 static int constructor_constant;
4956 /* 1 if so far this constructor's elements are all valid address constants. */
4957 static int constructor_simple;
4959 /* 1 if this constructor is erroneous so far. */
4960 static int constructor_erroneous;
4962 /* 1 if have called defer_addressed_constants. */
4963 static int constructor_subconstants_deferred;
4965 /* Structure for managing pending initializer elements, organized as an
4970 struct init_node *left, *right;
4971 struct init_node *parent;
4977 /* Tree of pending elements at this constructor level.
4978 These are elements encountered out of order
4979 which belong at places we haven't reached yet in actually
4981 Will never hold tree nodes across GC runs. */
4982 static struct init_node *constructor_pending_elts;
4984 /* The SPELLING_DEPTH of this constructor. */
4985 static int constructor_depth;
4987 /* 0 if implicitly pushing constructor levels is allowed. */
4988 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4990 static int require_constant_value;
4991 static int require_constant_elements;
4993 /* DECL node for which an initializer is being read.
4994 0 means we are reading a constructor expression
4995 such as (struct foo) {...}. */
4996 static tree constructor_decl;
4998 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4999 static const char *constructor_asmspec;
5001 /* Nonzero if this is an initializer for a top-level decl. */
5002 static int constructor_top_level;
5004 /* Nonzero if there were any member designators in this initializer. */
5005 static int constructor_designated;
5007 /* Nesting depth of designator list. */
5008 static int designator_depth;
5010 /* Nonzero if there were diagnosed errors in this designator list. */
5011 static int designator_errorneous;
5014 /* This stack has a level for each implicit or explicit level of
5015 structuring in the initializer, including the outermost one. It
5016 saves the values of most of the variables above. */
5018 struct constructor_range_stack;
5020 struct constructor_stack
5022 struct constructor_stack *next;
5027 tree unfilled_index;
5028 tree unfilled_fields;
5031 struct init_node *pending_elts;
5034 /* If nonzero, this value should replace the entire
5035 constructor at this level. */
5036 tree replacement_value;
5037 struct constructor_range_stack *range_stack;
5047 struct constructor_stack *constructor_stack;
5049 /* This stack represents designators from some range designator up to
5050 the last designator in the list. */
5052 struct constructor_range_stack
5054 struct constructor_range_stack *next, *prev;
5055 struct constructor_stack *stack;
5062 struct constructor_range_stack *constructor_range_stack;
5064 /* This stack records separate initializers that are nested.
5065 Nested initializers can't happen in ANSI C, but GNU C allows them
5066 in cases like { ... (struct foo) { ... } ... }. */
5068 struct initializer_stack
5070 struct initializer_stack *next;
5072 const char *asmspec;
5073 struct constructor_stack *constructor_stack;
5074 struct constructor_range_stack *constructor_range_stack;
5076 struct spelling *spelling;
5077 struct spelling *spelling_base;
5080 char require_constant_value;
5081 char require_constant_elements;
5085 struct initializer_stack *initializer_stack;
5087 /* Prepare to parse and output the initializer for variable DECL. */
5090 start_init (decl, asmspec_tree, top_level)
5096 struct initializer_stack *p
5097 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5098 const char *asmspec = 0;
5101 asmspec = TREE_STRING_POINTER (asmspec_tree);
5103 p->decl = constructor_decl;
5104 p->asmspec = constructor_asmspec;
5105 p->require_constant_value = require_constant_value;
5106 p->require_constant_elements = require_constant_elements;
5107 p->constructor_stack = constructor_stack;
5108 p->constructor_range_stack = constructor_range_stack;
5109 p->elements = constructor_elements;
5110 p->spelling = spelling;
5111 p->spelling_base = spelling_base;
5112 p->spelling_size = spelling_size;
5113 p->deferred = constructor_subconstants_deferred;
5114 p->top_level = constructor_top_level;
5115 p->next = initializer_stack;
5116 initializer_stack = p;
5118 constructor_decl = decl;
5119 constructor_asmspec = asmspec;
5120 constructor_subconstants_deferred = 0;
5121 constructor_designated = 0;
5122 constructor_top_level = top_level;
5126 require_constant_value = TREE_STATIC (decl);
5127 require_constant_elements
5128 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5129 /* For a scalar, you can always use any value to initialize,
5130 even within braces. */
5131 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5132 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5133 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5134 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5135 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5139 require_constant_value = 0;
5140 require_constant_elements = 0;
5141 locus = "(anonymous)";
5144 constructor_stack = 0;
5145 constructor_range_stack = 0;
5147 missing_braces_mentioned = 0;
5151 RESTORE_SPELLING_DEPTH (0);
5154 push_string (locus);
5160 struct initializer_stack *p = initializer_stack;
5162 /* Output subconstants (string constants, usually)
5163 that were referenced within this initializer and saved up.
5164 Must do this if and only if we called defer_addressed_constants. */
5165 if (constructor_subconstants_deferred)
5166 output_deferred_addressed_constants ();
5168 /* Free the whole constructor stack of this initializer. */
5169 while (constructor_stack)
5171 struct constructor_stack *q = constructor_stack;
5172 constructor_stack = q->next;
5176 if (constructor_range_stack)
5179 /* Pop back to the data of the outer initializer (if any). */
5180 constructor_decl = p->decl;
5181 constructor_asmspec = p->asmspec;
5182 require_constant_value = p->require_constant_value;
5183 require_constant_elements = p->require_constant_elements;
5184 constructor_stack = p->constructor_stack;
5185 constructor_range_stack = p->constructor_range_stack;
5186 constructor_elements = p->elements;
5187 spelling = p->spelling;
5188 spelling_base = p->spelling_base;
5189 spelling_size = p->spelling_size;
5190 constructor_subconstants_deferred = p->deferred;
5191 constructor_top_level = p->top_level;
5192 initializer_stack = p->next;
5196 /* Call here when we see the initializer is surrounded by braces.
5197 This is instead of a call to push_init_level;
5198 it is matched by a call to pop_init_level.
5200 TYPE is the type to initialize, for a constructor expression.
5201 For an initializer for a decl, TYPE is zero. */
5204 really_start_incremental_init (type)
5207 struct constructor_stack *p
5208 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5211 type = TREE_TYPE (constructor_decl);
5213 p->type = constructor_type;
5214 p->fields = constructor_fields;
5215 p->index = constructor_index;
5216 p->max_index = constructor_max_index;
5217 p->unfilled_index = constructor_unfilled_index;
5218 p->unfilled_fields = constructor_unfilled_fields;
5219 p->bit_index = constructor_bit_index;
5220 p->elements = constructor_elements;
5221 p->constant = constructor_constant;
5222 p->simple = constructor_simple;
5223 p->erroneous = constructor_erroneous;
5224 p->pending_elts = constructor_pending_elts;
5225 p->depth = constructor_depth;
5226 p->replacement_value = 0;
5230 p->incremental = constructor_incremental;
5231 p->designated = constructor_designated;
5233 constructor_stack = p;
5235 constructor_constant = 1;
5236 constructor_simple = 1;
5237 constructor_depth = SPELLING_DEPTH ();
5238 constructor_elements = 0;
5239 constructor_pending_elts = 0;
5240 constructor_type = type;
5241 constructor_incremental = 1;
5242 constructor_designated = 0;
5243 designator_depth = 0;
5244 designator_errorneous = 0;
5246 if (TREE_CODE (constructor_type) == RECORD_TYPE
5247 || TREE_CODE (constructor_type) == UNION_TYPE)
5249 constructor_fields = TYPE_FIELDS (constructor_type);
5250 /* Skip any nameless bit fields at the beginning. */
5251 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5252 && DECL_NAME (constructor_fields) == 0)
5253 constructor_fields = TREE_CHAIN (constructor_fields);
5255 constructor_unfilled_fields = constructor_fields;
5256 constructor_bit_index = bitsize_zero_node;
5258 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5260 if (TYPE_DOMAIN (constructor_type))
5262 constructor_max_index
5263 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5265 /* Detect non-empty initializations of zero-length arrays. */
5266 if (constructor_max_index == NULL_TREE
5267 && TYPE_SIZE (constructor_type))
5268 constructor_max_index = build_int_2 (-1, -1);
5270 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5271 to initialize VLAs will cause an proper error; avoid tree
5272 checking errors as well by setting a safe value. */
5273 if (constructor_max_index
5274 && TREE_CODE (constructor_max_index) != INTEGER_CST)
5275 constructor_max_index = build_int_2 (-1, -1);
5278 = convert (bitsizetype,
5279 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5282 constructor_index = bitsize_zero_node;
5284 constructor_unfilled_index = constructor_index;
5288 /* Handle the case of int x = {5}; */
5289 constructor_fields = constructor_type;
5290 constructor_unfilled_fields = constructor_type;
5294 /* Push down into a subobject, for initialization.
5295 If this is for an explicit set of braces, IMPLICIT is 0.
5296 If it is because the next element belongs at a lower level,
5297 IMPLICIT is 1 (or 2 if the push is because of designator list). */
5300 push_init_level (implicit)
5303 struct constructor_stack *p;
5304 tree value = NULL_TREE;
5306 /* If we've exhausted any levels that didn't have braces,
5308 while (constructor_stack->implicit)
5310 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5311 || TREE_CODE (constructor_type) == UNION_TYPE)
5312 && constructor_fields == 0)
5313 process_init_element (pop_init_level (1));
5314 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5315 && tree_int_cst_lt (constructor_max_index, constructor_index))
5316 process_init_element (pop_init_level (1));
5321 /* Unless this is an explicit brace, we need to preserve previous
5325 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5326 || TREE_CODE (constructor_type) == UNION_TYPE)
5327 && constructor_fields)
5328 value = find_init_member (constructor_fields);
5329 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5330 value = find_init_member (constructor_index);
5333 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5334 p->type = constructor_type;
5335 p->fields = constructor_fields;
5336 p->index = constructor_index;
5337 p->max_index = constructor_max_index;
5338 p->unfilled_index = constructor_unfilled_index;
5339 p->unfilled_fields = constructor_unfilled_fields;
5340 p->bit_index = constructor_bit_index;
5341 p->elements = constructor_elements;
5342 p->constant = constructor_constant;
5343 p->simple = constructor_simple;
5344 p->erroneous = constructor_erroneous;
5345 p->pending_elts = constructor_pending_elts;
5346 p->depth = constructor_depth;
5347 p->replacement_value = 0;
5348 p->implicit = implicit;
5350 p->incremental = constructor_incremental;
5351 p->designated = constructor_designated;
5352 p->next = constructor_stack;
5354 constructor_stack = p;
5356 constructor_constant = 1;
5357 constructor_simple = 1;
5358 constructor_depth = SPELLING_DEPTH ();
5359 constructor_elements = 0;
5360 constructor_incremental = 1;
5361 constructor_designated = 0;
5362 constructor_pending_elts = 0;
5365 p->range_stack = constructor_range_stack;
5366 constructor_range_stack = 0;
5367 designator_depth = 0;
5368 designator_errorneous = 0;
5371 /* Don't die if an entire brace-pair level is superfluous
5372 in the containing level. */
5373 if (constructor_type == 0)
5375 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5376 || TREE_CODE (constructor_type) == UNION_TYPE)
5378 /* Don't die if there are extra init elts at the end. */
5379 if (constructor_fields == 0)
5380 constructor_type = 0;
5383 constructor_type = TREE_TYPE (constructor_fields);
5384 push_member_name (constructor_fields);
5385 constructor_depth++;
5388 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5390 constructor_type = TREE_TYPE (constructor_type);
5391 push_array_bounds (tree_low_cst (constructor_index, 0));
5392 constructor_depth++;
5395 if (constructor_type == 0)
5397 error_init ("extra brace group at end of initializer");
5398 constructor_fields = 0;
5399 constructor_unfilled_fields = 0;
5403 if (value && TREE_CODE (value) == CONSTRUCTOR)
5405 constructor_constant = TREE_CONSTANT (value);
5406 constructor_simple = TREE_STATIC (value);
5407 constructor_elements = TREE_OPERAND (value, 1);
5408 if (constructor_elements
5409 && (TREE_CODE (constructor_type) == RECORD_TYPE
5410 || TREE_CODE (constructor_type) == ARRAY_TYPE))
5411 set_nonincremental_init ();
5414 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5416 missing_braces_mentioned = 1;
5417 warning_init ("missing braces around initializer");
5420 if (TREE_CODE (constructor_type) == RECORD_TYPE
5421 || TREE_CODE (constructor_type) == UNION_TYPE)
5423 constructor_fields = TYPE_FIELDS (constructor_type);
5424 /* Skip any nameless bit fields at the beginning. */
5425 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5426 && DECL_NAME (constructor_fields) == 0)
5427 constructor_fields = TREE_CHAIN (constructor_fields);
5429 constructor_unfilled_fields = constructor_fields;
5430 constructor_bit_index = bitsize_zero_node;
5432 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5434 if (TYPE_DOMAIN (constructor_type))
5436 constructor_max_index
5437 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5439 /* Detect non-empty initializations of zero-length arrays. */
5440 if (constructor_max_index == NULL_TREE
5441 && TYPE_SIZE (constructor_type))
5442 constructor_max_index = build_int_2 (-1, -1);
5444 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5445 to initialize VLAs will cause an proper error; avoid tree
5446 checking errors as well by setting a safe value. */
5447 if (constructor_max_index
5448 && TREE_CODE (constructor_max_index) != INTEGER_CST)
5449 constructor_max_index = build_int_2 (-1, -1);
5452 = convert (bitsizetype,
5453 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5456 constructor_index = bitsize_zero_node;
5458 constructor_unfilled_index = constructor_index;
5459 if (value && TREE_CODE (value) == STRING_CST)
5461 /* We need to split the char/wchar array into individual
5462 characters, so that we don't have to special case it
5464 set_nonincremental_init_from_string (value);
5469 warning_init ("braces around scalar initializer");
5470 constructor_fields = constructor_type;
5471 constructor_unfilled_fields = constructor_type;
5475 /* At the end of an implicit or explicit brace level,
5476 finish up that level of constructor.
5477 If we were outputting the elements as they are read, return 0
5478 from inner levels (process_init_element ignores that),
5479 but return error_mark_node from the outermost level
5480 (that's what we want to put in DECL_INITIAL).
5481 Otherwise, return a CONSTRUCTOR expression. */
5484 pop_init_level (implicit)
5487 struct constructor_stack *p;
5488 tree constructor = 0;
5492 /* When we come to an explicit close brace,
5493 pop any inner levels that didn't have explicit braces. */
5494 while (constructor_stack->implicit)
5495 process_init_element (pop_init_level (1));
5497 if (constructor_range_stack)
5501 p = constructor_stack;
5503 /* Error for initializing a flexible array member, or a zero-length
5504 array member in an inappropriate context. */
5505 if (constructor_type && constructor_fields
5506 && TREE_CODE (constructor_type) == ARRAY_TYPE
5507 && TYPE_DOMAIN (constructor_type)
5508 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5510 /* Silently discard empty initializations. The parser will
5511 already have pedwarned for empty brackets. */
5512 if (integer_zerop (constructor_unfilled_index))
5513 constructor_type = NULL_TREE;
5514 else if (! TYPE_SIZE (constructor_type))
5516 if (constructor_depth > 2)
5517 error_init ("initialization of flexible array member in a nested context");
5519 pedwarn_init ("initialization of a flexible array member");
5521 /* We have already issued an error message for the existence
5522 of a flexible array member not at the end of the structure.
5523 Discard the initializer so that we do not abort later. */
5524 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5525 constructor_type = NULL_TREE;
5528 /* Zero-length arrays are no longer special, so we should no longer
5533 /* Warn when some struct elements are implicitly initialized to zero. */
5536 && TREE_CODE (constructor_type) == RECORD_TYPE
5537 && constructor_unfilled_fields)
5539 /* Do not warn for flexible array members or zero-length arrays. */
5540 while (constructor_unfilled_fields
5541 && (! DECL_SIZE (constructor_unfilled_fields)
5542 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5543 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5545 /* Do not warn if this level of the initializer uses member
5546 designators; it is likely to be deliberate. */
5547 if (constructor_unfilled_fields && !constructor_designated)
5549 push_member_name (constructor_unfilled_fields);
5550 warning_init ("missing initializer");
5551 RESTORE_SPELLING_DEPTH (constructor_depth);
5555 /* Now output all pending elements. */
5556 constructor_incremental = 1;
5557 output_pending_init_elements (1);
5559 /* Pad out the end of the structure. */
5560 if (p->replacement_value)
5561 /* If this closes a superfluous brace pair,
5562 just pass out the element between them. */
5563 constructor = p->replacement_value;
5564 else if (constructor_type == 0)
5566 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5567 && TREE_CODE (constructor_type) != UNION_TYPE
5568 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5570 /* A nonincremental scalar initializer--just return
5571 the element, after verifying there is just one. */
5572 if (constructor_elements == 0)
5574 if (!constructor_erroneous)
5575 error_init ("empty scalar initializer");
5576 constructor = error_mark_node;
5578 else if (TREE_CHAIN (constructor_elements) != 0)
5580 error_init ("extra elements in scalar initializer");
5581 constructor = TREE_VALUE (constructor_elements);
5584 constructor = TREE_VALUE (constructor_elements);
5588 if (constructor_erroneous)
5589 constructor = error_mark_node;
5592 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5593 nreverse (constructor_elements));
5594 if (constructor_constant)
5595 TREE_CONSTANT (constructor) = 1;
5596 if (constructor_constant && constructor_simple)
5597 TREE_STATIC (constructor) = 1;
5601 constructor_type = p->type;
5602 constructor_fields = p->fields;
5603 constructor_index = p->index;
5604 constructor_max_index = p->max_index;
5605 constructor_unfilled_index = p->unfilled_index;
5606 constructor_unfilled_fields = p->unfilled_fields;
5607 constructor_bit_index = p->bit_index;
5608 constructor_elements = p->elements;
5609 constructor_constant = p->constant;
5610 constructor_simple = p->simple;
5611 constructor_erroneous = p->erroneous;
5612 constructor_incremental = p->incremental;
5613 constructor_designated = p->designated;
5614 constructor_pending_elts = p->pending_elts;
5615 constructor_depth = p->depth;
5617 constructor_range_stack = p->range_stack;
5618 RESTORE_SPELLING_DEPTH (constructor_depth);
5620 constructor_stack = p->next;
5623 if (constructor == 0)
5625 if (constructor_stack == 0)
5626 return error_mark_node;
5632 /* Common handling for both array range and field name designators.
5633 ARRAY argument is non-zero for array ranges. Returns zero for success. */
5636 set_designator (array)
5640 enum tree_code subcode;
5642 /* Don't die if an entire brace-pair level is superfluous
5643 in the containing level. */
5644 if (constructor_type == 0)
5647 /* If there were errors in this designator list already, bail out silently. */
5648 if (designator_errorneous)
5651 if (!designator_depth)
5653 if (constructor_range_stack)
5656 /* Designator list starts at the level of closest explicit
5658 while (constructor_stack->implicit)
5659 process_init_element (pop_init_level (1));
5660 constructor_designated = 1;
5664 if (constructor_no_implicit)
5666 error_init ("initialization designators may not nest");
5670 if (TREE_CODE (constructor_type) == RECORD_TYPE
5671 || TREE_CODE (constructor_type) == UNION_TYPE)
5673 subtype = TREE_TYPE (constructor_fields);
5674 if (subtype != error_mark_node)
5675 subtype = TYPE_MAIN_VARIANT (subtype);
5677 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5679 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5684 subcode = TREE_CODE (subtype);
5685 if (array && subcode != ARRAY_TYPE)
5687 error_init ("array index in non-array initializer");
5690 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5692 error_init ("field name not in record or union initializer");
5696 constructor_designated = 1;
5697 push_init_level (2);
5701 /* If there are range designators in designator list, push a new designator
5702 to constructor_range_stack. RANGE_END is end of such stack range or
5703 NULL_TREE if there is no range designator at this level. */
5706 push_range_stack (range_end)
5709 struct constructor_range_stack *p;
5711 p = (struct constructor_range_stack *)
5712 ggc_alloc (sizeof (struct constructor_range_stack));
5713 p->prev = constructor_range_stack;
5715 p->fields = constructor_fields;
5716 p->range_start = constructor_index;
5717 p->index = constructor_index;
5718 p->stack = constructor_stack;
5719 p->range_end = range_end;
5720 if (constructor_range_stack)
5721 constructor_range_stack->next = p;
5722 constructor_range_stack = p;
5725 /* Within an array initializer, specify the next index to be initialized.
5726 FIRST is that index. If LAST is nonzero, then initialize a range
5727 of indices, running from FIRST through LAST. */
5730 set_init_index (first, last)
5733 if (set_designator (1))
5736 designator_errorneous = 1;
5738 while ((TREE_CODE (first) == NOP_EXPR
5739 || TREE_CODE (first) == CONVERT_EXPR
5740 || TREE_CODE (first) == NON_LVALUE_EXPR)
5741 && (TYPE_MODE (TREE_TYPE (first))
5742 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5743 first = TREE_OPERAND (first, 0);
5746 while ((TREE_CODE (last) == NOP_EXPR
5747 || TREE_CODE (last) == CONVERT_EXPR
5748 || TREE_CODE (last) == NON_LVALUE_EXPR)
5749 && (TYPE_MODE (TREE_TYPE (last))
5750 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5751 last = TREE_OPERAND (last, 0);
5753 if (TREE_CODE (first) != INTEGER_CST)
5754 error_init ("nonconstant array index in initializer");
5755 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5756 error_init ("nonconstant array index in initializer");
5757 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5758 error_init ("array index in non-array initializer");
5759 else if (constructor_max_index
5760 && tree_int_cst_lt (constructor_max_index, first))
5761 error_init ("array index in initializer exceeds array bounds");
5764 constructor_index = convert (bitsizetype, first);
5768 if (tree_int_cst_equal (first, last))
5770 else if (tree_int_cst_lt (last, first))
5772 error_init ("empty index range in initializer");
5777 last = convert (bitsizetype, last);
5778 if (constructor_max_index != 0
5779 && tree_int_cst_lt (constructor_max_index, last))
5781 error_init ("array index range in initializer exceeds array bounds");
5788 designator_errorneous = 0;
5789 if (constructor_range_stack || last)
5790 push_range_stack (last);
5794 /* Within a struct initializer, specify the next field to be initialized. */
5797 set_init_label (fieldname)
5802 if (set_designator (0))
5805 designator_errorneous = 1;
5807 if (TREE_CODE (constructor_type) != RECORD_TYPE
5808 && TREE_CODE (constructor_type) != UNION_TYPE)
5810 error_init ("field name not in record or union initializer");
5814 for (tail = TYPE_FIELDS (constructor_type); tail;
5815 tail = TREE_CHAIN (tail))
5817 if (DECL_NAME (tail) == fieldname)
5822 error ("unknown field `%s' specified in initializer",
5823 IDENTIFIER_POINTER (fieldname));
5826 constructor_fields = tail;
5828 designator_errorneous = 0;
5829 if (constructor_range_stack)
5830 push_range_stack (NULL_TREE);
5834 /* Add a new initializer to the tree of pending initializers. PURPOSE
5835 identifies the initializer, either array index or field in a structure.
5836 VALUE is the value of that index or field. */
5839 add_pending_init (purpose, value)
5840 tree purpose, value;
5842 struct init_node *p, **q, *r;
5844 q = &constructor_pending_elts;
5847 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5852 if (tree_int_cst_lt (purpose, p->purpose))
5854 else if (tree_int_cst_lt (p->purpose, purpose))
5858 if (TREE_SIDE_EFFECTS (p->value))
5859 warning_init ("initialized field with side-effects overwritten");
5869 bitpos = bit_position (purpose);
5873 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5875 else if (p->purpose != purpose)
5879 if (TREE_SIDE_EFFECTS (p->value))
5880 warning_init ("initialized field with side-effects overwritten");
5887 r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5888 r->purpose = purpose;
5899 struct init_node *s;
5903 if (p->balance == 0)
5905 else if (p->balance < 0)
5912 p->left->parent = p;
5929 constructor_pending_elts = r;
5934 struct init_node *t = r->right;
5938 r->right->parent = r;
5943 p->left->parent = p;
5946 p->balance = t->balance < 0;
5947 r->balance = -(t->balance > 0);
5962 constructor_pending_elts = t;
5968 /* p->balance == +1; growth of left side balances the node. */
5973 else /* r == p->right */
5975 if (p->balance == 0)
5976 /* Growth propagation from right side. */
5978 else if (p->balance > 0)
5985 p->right->parent = p;
6002 constructor_pending_elts = r;
6004 else /* r->balance == -1 */
6007 struct init_node *t = r->left;
6011 r->left->parent = r;
6016 p->right->parent = p;
6019 r->balance = (t->balance < 0);
6020 p->balance = -(t->balance > 0);
6035 constructor_pending_elts = t;
6041 /* p->balance == -1; growth of right side balances the node. */
6052 /* Build AVL tree from a sorted chain. */
6055 set_nonincremental_init ()
6059 if (TREE_CODE (constructor_type) != RECORD_TYPE
6060 && TREE_CODE (constructor_type) != ARRAY_TYPE)
6063 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
6064 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
6065 constructor_elements = 0;
6066 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6068 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6069 /* Skip any nameless bit fields at the beginning. */
6070 while (constructor_unfilled_fields != 0
6071 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6072 && DECL_NAME (constructor_unfilled_fields) == 0)
6073 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6076 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6078 if (TYPE_DOMAIN (constructor_type))
6079 constructor_unfilled_index
6080 = convert (bitsizetype,
6081 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6083 constructor_unfilled_index = bitsize_zero_node;
6085 constructor_incremental = 0;
6088 /* Build AVL tree from a string constant. */
6091 set_nonincremental_init_from_string (str)
6094 tree value, purpose, type;
6095 HOST_WIDE_INT val[2];
6096 const char *p, *end;
6097 int byte, wchar_bytes, charwidth, bitpos;
6099 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6102 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6103 == TYPE_PRECISION (char_type_node))
6105 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6106 == TYPE_PRECISION (wchar_type_node))
6107 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6111 charwidth = TYPE_PRECISION (char_type_node);
6112 type = TREE_TYPE (constructor_type);
6113 p = TREE_STRING_POINTER (str);
6114 end = p + TREE_STRING_LENGTH (str);
6116 for (purpose = bitsize_zero_node;
6117 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6118 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6120 if (wchar_bytes == 1)
6122 val[1] = (unsigned char) *p++;
6129 for (byte = 0; byte < wchar_bytes; byte++)
6131 if (BYTES_BIG_ENDIAN)
6132 bitpos = (wchar_bytes - byte - 1) * charwidth;
6134 bitpos = byte * charwidth;
6135 val[bitpos < HOST_BITS_PER_WIDE_INT]
6136 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6137 << (bitpos % HOST_BITS_PER_WIDE_INT);
6141 if (!TREE_UNSIGNED (type))
6143 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6144 if (bitpos < HOST_BITS_PER_WIDE_INT)
6146 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6148 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6152 else if (bitpos == HOST_BITS_PER_WIDE_INT)
6157 else if (val[0] & (((HOST_WIDE_INT) 1)
6158 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6159 val[0] |= ((HOST_WIDE_INT) -1)
6160 << (bitpos - HOST_BITS_PER_WIDE_INT);
6163 value = build_int_2 (val[1], val[0]);
6164 TREE_TYPE (value) = type;
6165 add_pending_init (purpose, value);
6168 constructor_incremental = 0;
6171 /* Return value of FIELD in pending initializer or zero if the field was
6172 not initialized yet. */
6175 find_init_member (field)
6178 struct init_node *p;
6180 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6182 if (constructor_incremental
6183 && tree_int_cst_lt (field, constructor_unfilled_index))
6184 set_nonincremental_init ();
6186 p = constructor_pending_elts;
6189 if (tree_int_cst_lt (field, p->purpose))
6191 else if (tree_int_cst_lt (p->purpose, field))
6197 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6199 tree bitpos = bit_position (field);
6201 if (constructor_incremental
6202 && (!constructor_unfilled_fields
6203 || tree_int_cst_lt (bitpos,
6204 bit_position (constructor_unfilled_fields))))
6205 set_nonincremental_init ();
6207 p = constructor_pending_elts;
6210 if (field == p->purpose)
6212 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6218 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6220 if (constructor_elements
6221 && TREE_PURPOSE (constructor_elements) == field)
6222 return TREE_VALUE (constructor_elements);
6227 /* "Output" the next constructor element.
6228 At top level, really output it to assembler code now.
6229 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6230 TYPE is the data type that the containing data type wants here.
6231 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6233 PENDING if non-nil means output pending elements that belong
6234 right after this element. (PENDING is normally 1;
6235 it is 0 while outputting pending elements, to avoid recursion.) */
6238 output_init_element (value, type, field, pending)
6239 tree value, type, field;
6242 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6243 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6244 && !(TREE_CODE (value) == STRING_CST
6245 && TREE_CODE (type) == ARRAY_TYPE
6246 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6247 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6248 TYPE_MAIN_VARIANT (type))))
6249 value = default_conversion (value);
6251 if (value == error_mark_node)
6252 constructor_erroneous = 1;
6253 else if (!TREE_CONSTANT (value))
6254 constructor_constant = 0;
6255 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6256 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6257 || TREE_CODE (constructor_type) == UNION_TYPE)
6258 && DECL_C_BIT_FIELD (field)
6259 && TREE_CODE (value) != INTEGER_CST))
6260 constructor_simple = 0;
6262 if (require_constant_value && ! TREE_CONSTANT (value))
6264 error_init ("initializer element is not constant");
6265 value = error_mark_node;
6267 else if (require_constant_elements
6268 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6269 pedwarn ("initializer element is not computable at load time");
6271 /* If this field is empty (and not at the end of structure),
6272 don't do anything other than checking the initializer. */
6274 && (TREE_TYPE (field) == error_mark_node
6275 || (COMPLETE_TYPE_P (TREE_TYPE (field))
6276 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6277 && (TREE_CODE (constructor_type) == ARRAY_TYPE
6278 || TREE_CHAIN (field)))))
6281 value = digest_init (type, value, require_constant_value,
6282 require_constant_elements);
6283 if (value == error_mark_node)
6285 constructor_erroneous = 1;
6289 /* If this element doesn't come next in sequence,
6290 put it on constructor_pending_elts. */
6291 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6292 && (!constructor_incremental
6293 || !tree_int_cst_equal (field, constructor_unfilled_index)))
6295 if (constructor_incremental
6296 && tree_int_cst_lt (field, constructor_unfilled_index))
6297 set_nonincremental_init ();
6299 add_pending_init (field, value);
6302 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6303 && (!constructor_incremental
6304 || field != constructor_unfilled_fields))
6306 /* We do this for records but not for unions. In a union,
6307 no matter which field is specified, it can be initialized
6308 right away since it starts at the beginning of the union. */
6309 if (constructor_incremental)
6311 if (!constructor_unfilled_fields)
6312 set_nonincremental_init ();
6315 tree bitpos, unfillpos;
6317 bitpos = bit_position (field);
6318 unfillpos = bit_position (constructor_unfilled_fields);
6320 if (tree_int_cst_lt (bitpos, unfillpos))
6321 set_nonincremental_init ();
6325 add_pending_init (field, value);
6328 else if (TREE_CODE (constructor_type) == UNION_TYPE
6329 && constructor_elements)
6331 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6332 warning_init ("initialized field with side-effects overwritten");
6334 /* We can have just one union field set. */
6335 constructor_elements = 0;
6338 /* Otherwise, output this element either to
6339 constructor_elements or to the assembler file. */
6341 if (field && TREE_CODE (field) == INTEGER_CST)
6342 field = copy_node (field);
6343 constructor_elements
6344 = tree_cons (field, value, constructor_elements);
6346 /* Advance the variable that indicates sequential elements output. */
6347 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6348 constructor_unfilled_index
6349 = size_binop (PLUS_EXPR, constructor_unfilled_index,
6351 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6353 constructor_unfilled_fields
6354 = TREE_CHAIN (constructor_unfilled_fields);
6356 /* Skip any nameless bit fields. */
6357 while (constructor_unfilled_fields != 0
6358 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6359 && DECL_NAME (constructor_unfilled_fields) == 0)
6360 constructor_unfilled_fields =
6361 TREE_CHAIN (constructor_unfilled_fields);
6363 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6364 constructor_unfilled_fields = 0;
6366 /* Now output any pending elements which have become next. */
6368 output_pending_init_elements (0);
6371 /* Output any pending elements which have become next.
6372 As we output elements, constructor_unfilled_{fields,index}
6373 advances, which may cause other elements to become next;
6374 if so, they too are output.
6376 If ALL is 0, we return when there are
6377 no more pending elements to output now.
6379 If ALL is 1, we output space as necessary so that
6380 we can output all the pending elements. */
6383 output_pending_init_elements (all)
6386 struct init_node *elt = constructor_pending_elts;
6391 /* Look thru the whole pending tree.
6392 If we find an element that should be output now,
6393 output it. Otherwise, set NEXT to the element
6394 that comes first among those still pending. */
6399 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6401 if (tree_int_cst_equal (elt->purpose,
6402 constructor_unfilled_index))
6403 output_init_element (elt->value,
6404 TREE_TYPE (constructor_type),
6405 constructor_unfilled_index, 0);
6406 else if (tree_int_cst_lt (constructor_unfilled_index,
6409 /* Advance to the next smaller node. */
6414 /* We have reached the smallest node bigger than the
6415 current unfilled index. Fill the space first. */
6416 next = elt->purpose;
6422 /* Advance to the next bigger node. */
6427 /* We have reached the biggest node in a subtree. Find
6428 the parent of it, which is the next bigger node. */
6429 while (elt->parent && elt->parent->right == elt)
6432 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6435 next = elt->purpose;
6441 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6442 || TREE_CODE (constructor_type) == UNION_TYPE)
6444 tree ctor_unfilled_bitpos, elt_bitpos;
6446 /* If the current record is complete we are done. */
6447 if (constructor_unfilled_fields == 0)
6450 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6451 elt_bitpos = bit_position (elt->purpose);
6452 /* We can't compare fields here because there might be empty
6453 fields in between. */
6454 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6456 constructor_unfilled_fields = elt->purpose;
6457 output_init_element (elt->value, TREE_TYPE (elt->purpose),
6460 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6462 /* Advance to the next smaller node. */
6467 /* We have reached the smallest node bigger than the
6468 current unfilled field. Fill the space first. */
6469 next = elt->purpose;
6475 /* Advance to the next bigger node. */
6480 /* We have reached the biggest node in a subtree. Find
6481 the parent of it, which is the next bigger node. */
6482 while (elt->parent && elt->parent->right == elt)
6486 && (tree_int_cst_lt (ctor_unfilled_bitpos,
6487 bit_position (elt->purpose))))
6489 next = elt->purpose;
6497 /* Ordinarily return, but not if we want to output all
6498 and there are elements left. */
6499 if (! (all && next != 0))
6502 /* If it's not incremental, just skip over the gap, so that after
6503 jumping to retry we will output the next successive element. */
6504 if (TREE_CODE (constructor_type) == RECORD_TYPE
6505 || TREE_CODE (constructor_type) == UNION_TYPE)
6506 constructor_unfilled_fields = next;
6507 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6508 constructor_unfilled_index = next;
6510 /* ELT now points to the node in the pending tree with the next
6511 initializer to output. */
6515 /* Add one non-braced element to the current constructor level.
6516 This adjusts the current position within the constructor's type.
6517 This may also start or terminate implicit levels
6518 to handle a partly-braced initializer.
6520 Once this has found the correct level for the new element,
6521 it calls output_init_element. */
6524 process_init_element (value)
6527 tree orig_value = value;
6528 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6530 designator_depth = 0;
6531 designator_errorneous = 0;
6533 /* Handle superfluous braces around string cst as in
6534 char x[] = {"foo"}; */
6537 && TREE_CODE (constructor_type) == ARRAY_TYPE
6538 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6539 && integer_zerop (constructor_unfilled_index))
6541 if (constructor_stack->replacement_value)
6542 error_init ("excess elements in char array initializer");
6543 constructor_stack->replacement_value = value;
6547 if (constructor_stack->replacement_value != 0)
6549 error_init ("excess elements in struct initializer");
6553 /* Ignore elements of a brace group if it is entirely superfluous
6554 and has already been diagnosed. */
6555 if (constructor_type == 0)
6558 /* If we've exhausted any levels that didn't have braces,
6560 while (constructor_stack->implicit)
6562 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6563 || TREE_CODE (constructor_type) == UNION_TYPE)
6564 && constructor_fields == 0)
6565 process_init_element (pop_init_level (1));
6566 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6567 && (constructor_max_index == 0
6568 || tree_int_cst_lt (constructor_max_index,
6569 constructor_index)))
6570 process_init_element (pop_init_level (1));
6575 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6576 if (constructor_range_stack)
6577 value = save_expr (value);
6581 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6584 enum tree_code fieldcode;
6586 if (constructor_fields == 0)
6588 pedwarn_init ("excess elements in struct initializer");
6592 fieldtype = TREE_TYPE (constructor_fields);
6593 if (fieldtype != error_mark_node)
6594 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6595 fieldcode = TREE_CODE (fieldtype);
6597 /* Accept a string constant to initialize a subarray. */
6599 && fieldcode == ARRAY_TYPE
6600 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6603 /* Otherwise, if we have come to a subaggregate,
6604 and we don't have an element of its type, push into it. */
6605 else if (value != 0 && !constructor_no_implicit
6606 && value != error_mark_node
6607 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6608 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6609 || fieldcode == UNION_TYPE))
6611 push_init_level (1);
6617 push_member_name (constructor_fields);
6618 output_init_element (value, fieldtype, constructor_fields, 1);
6619 RESTORE_SPELLING_DEPTH (constructor_depth);
6622 /* Do the bookkeeping for an element that was
6623 directly output as a constructor. */
6625 /* For a record, keep track of end position of last field. */
6626 if (DECL_SIZE (constructor_fields))
6627 constructor_bit_index
6628 = size_binop (PLUS_EXPR,
6629 bit_position (constructor_fields),
6630 DECL_SIZE (constructor_fields));
6632 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6633 /* Skip any nameless bit fields. */
6634 while (constructor_unfilled_fields != 0
6635 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6636 && DECL_NAME (constructor_unfilled_fields) == 0)
6637 constructor_unfilled_fields =
6638 TREE_CHAIN (constructor_unfilled_fields);
6641 constructor_fields = TREE_CHAIN (constructor_fields);
6642 /* Skip any nameless bit fields at the beginning. */
6643 while (constructor_fields != 0
6644 && DECL_C_BIT_FIELD (constructor_fields)
6645 && DECL_NAME (constructor_fields) == 0)
6646 constructor_fields = TREE_CHAIN (constructor_fields);
6648 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6651 enum tree_code fieldcode;
6653 if (constructor_fields == 0)
6655 pedwarn_init ("excess elements in union initializer");
6659 fieldtype = TREE_TYPE (constructor_fields);
6660 if (fieldtype != error_mark_node)
6661 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6662 fieldcode = TREE_CODE (fieldtype);
6664 /* Warn that traditional C rejects initialization of unions.
6665 We skip the warning if the value is zero. This is done
6666 under the assumption that the zero initializer in user
6667 code appears conditioned on e.g. __STDC__ to avoid
6668 "missing initializer" warnings and relies on default
6669 initialization to zero in the traditional C case.
6670 We also skip the warning if the initializer is designated,
6671 again on the assumption that this must be conditional on
6672 __STDC__ anyway (and we've already complained about the
6673 member-designator already). */
6674 if (warn_traditional && !in_system_header && !constructor_designated
6675 && !(value && (integer_zerop (value) || real_zerop (value))))
6676 warning ("traditional C rejects initialization of unions");
6678 /* Accept a string constant to initialize a subarray. */
6680 && fieldcode == ARRAY_TYPE
6681 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6684 /* Otherwise, if we have come to a subaggregate,
6685 and we don't have an element of its type, push into it. */
6686 else if (value != 0 && !constructor_no_implicit
6687 && value != error_mark_node
6688 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6689 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6690 || fieldcode == UNION_TYPE))
6692 push_init_level (1);
6698 push_member_name (constructor_fields);
6699 output_init_element (value, fieldtype, constructor_fields, 1);
6700 RESTORE_SPELLING_DEPTH (constructor_depth);
6703 /* Do the bookkeeping for an element that was
6704 directly output as a constructor. */
6706 constructor_bit_index = DECL_SIZE (constructor_fields);
6707 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6710 constructor_fields = 0;
6712 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6714 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6715 enum tree_code eltcode = TREE_CODE (elttype);
6717 /* Accept a string constant to initialize a subarray. */
6719 && eltcode == ARRAY_TYPE
6720 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6723 /* Otherwise, if we have come to a subaggregate,
6724 and we don't have an element of its type, push into it. */
6725 else if (value != 0 && !constructor_no_implicit
6726 && value != error_mark_node
6727 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6728 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6729 || eltcode == UNION_TYPE))
6731 push_init_level (1);
6735 if (constructor_max_index != 0
6736 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6737 || integer_all_onesp (constructor_max_index)))
6739 pedwarn_init ("excess elements in array initializer");
6743 /* Now output the actual element. */
6746 push_array_bounds (tree_low_cst (constructor_index, 0));
6747 output_init_element (value, elttype, constructor_index, 1);
6748 RESTORE_SPELLING_DEPTH (constructor_depth);
6752 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6755 /* If we are doing the bookkeeping for an element that was
6756 directly output as a constructor, we must update
6757 constructor_unfilled_index. */
6758 constructor_unfilled_index = constructor_index;
6761 /* Handle the sole element allowed in a braced initializer
6762 for a scalar variable. */
6763 else if (constructor_fields == 0)
6765 pedwarn_init ("excess elements in scalar initializer");
6771 output_init_element (value, constructor_type, NULL_TREE, 1);
6772 constructor_fields = 0;
6775 /* Handle range initializers either at this level or anywhere higher
6776 in the designator stack. */
6777 if (constructor_range_stack)
6779 struct constructor_range_stack *p, *range_stack;
6782 range_stack = constructor_range_stack;
6783 constructor_range_stack = 0;
6784 while (constructor_stack != range_stack->stack)
6786 if (!constructor_stack->implicit)
6788 process_init_element (pop_init_level (1));
6790 for (p = range_stack;
6791 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6794 if (!constructor_stack->implicit)
6796 process_init_element (pop_init_level (1));
6799 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6800 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6805 constructor_index = p->index;
6806 constructor_fields = p->fields;
6807 if (finish && p->range_end && p->index == p->range_start)
6815 push_init_level (2);
6816 p->stack = constructor_stack;
6817 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6818 p->index = p->range_start;
6822 constructor_range_stack = range_stack;
6829 constructor_range_stack = 0;
6832 /* Build a simple asm-statement, from one string literal. */
6834 simple_asm_stmt (expr)
6839 if (TREE_CODE (expr) == ADDR_EXPR)
6840 expr = TREE_OPERAND (expr, 0);
6842 if (TREE_CODE (expr) == STRING_CST)
6846 if (TREE_CHAIN (expr))
6847 expr = combine_strings (expr);
6848 stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6849 NULL_TREE, NULL_TREE,
6851 ASM_INPUT_P (stmt) = 1;
6855 error ("argument of `asm' is not a constant string");
6859 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6860 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6863 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6872 if (TREE_CHAIN (string))
6873 string = combine_strings (string);
6874 if (TREE_CODE (string) != STRING_CST)
6876 error ("asm template is not a string constant");
6880 if (cv_qualifier != NULL_TREE
6881 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6883 warning ("%s qualifier ignored on asm",
6884 IDENTIFIER_POINTER (cv_qualifier));
6885 cv_qualifier = NULL_TREE;
6888 /* We can remove output conversions that change the type,
6889 but not the mode. */
6890 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6892 tree output = TREE_VALUE (tail);
6894 STRIP_NOPS (output);
6895 TREE_VALUE (tail) = output;
6897 /* Allow conversions as LHS here. build_modify_expr as called below
6898 will do the right thing with them. */
6899 while (TREE_CODE (output) == NOP_EXPR
6900 || TREE_CODE (output) == CONVERT_EXPR
6901 || TREE_CODE (output) == FLOAT_EXPR
6902 || TREE_CODE (output) == FIX_TRUNC_EXPR
6903 || TREE_CODE (output) == FIX_FLOOR_EXPR
6904 || TREE_CODE (output) == FIX_ROUND_EXPR
6905 || TREE_CODE (output) == FIX_CEIL_EXPR)
6906 output = TREE_OPERAND (output, 0);
6908 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6911 /* Remove output conversions that change the type but not the mode. */
6912 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6914 tree output = TREE_VALUE (tail);
6915 STRIP_NOPS (output);
6916 TREE_VALUE (tail) = output;
6919 /* Perform default conversions on array and function inputs.
6920 Don't do this for other types as it would screw up operands
6921 expected to be in memory. */
6922 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6923 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6925 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6926 outputs, inputs, clobbers));
6929 /* Expand an ASM statement with operands, handling output operands
6930 that are not variables or INDIRECT_REFS by transforming such
6931 cases into cases that expand_asm_operands can handle.
6933 Arguments are same as for expand_asm_operands. */
6936 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6937 tree string, outputs, inputs, clobbers;
6939 const char *filename;
6942 int noutputs = list_length (outputs);
6944 /* o[I] is the place that output number I should be written. */
6945 tree *o = (tree *) alloca (noutputs * sizeof (tree));
6948 /* Record the contents of OUTPUTS before it is modified. */
6949 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6950 o[i] = TREE_VALUE (tail);
6952 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6953 OUTPUTS some trees for where the values were actually stored. */
6954 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6956 /* Copy all the intermediate outputs into the specified outputs. */
6957 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6959 if (o[i] != TREE_VALUE (tail))
6961 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6962 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6965 /* Restore the original value so that it's correct the next
6966 time we expand this function. */
6967 TREE_VALUE (tail) = o[i];
6969 /* Detect modification of read-only values.
6970 (Otherwise done by build_modify_expr.) */
6973 tree type = TREE_TYPE (o[i]);
6974 if (TREE_READONLY (o[i])
6975 || TYPE_READONLY (type)
6976 || ((TREE_CODE (type) == RECORD_TYPE
6977 || TREE_CODE (type) == UNION_TYPE)
6978 && C_TYPE_FIELDS_READONLY (type)))
6979 readonly_warning (o[i], "modification by `asm'");
6983 /* Those MODIFY_EXPRs could do autoincrements. */
6987 /* Expand a C `return' statement.
6988 RETVAL is the expression for what to return,
6989 or a null pointer for `return;' with no value. */
6992 c_expand_return (retval)
6995 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6997 if (TREE_THIS_VOLATILE (current_function_decl))
6998 warning ("function declared `noreturn' has a `return' statement");
7002 current_function_returns_null = 1;
7003 if ((warn_return_type || flag_isoc99)
7004 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7005 pedwarn_c99 ("`return' with no value, in function returning non-void");
7007 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7009 current_function_returns_null = 1;
7010 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7011 pedwarn ("`return' with a value, in function returning void");
7015 tree t = convert_for_assignment (valtype, retval, _("return"),
7016 NULL_TREE, NULL_TREE, 0);
7017 tree res = DECL_RESULT (current_function_decl);
7020 if (t == error_mark_node)
7023 inner = t = convert (TREE_TYPE (res), t);
7025 /* Strip any conversions, additions, and subtractions, and see if
7026 we are returning the address of a local variable. Warn if so. */
7029 switch (TREE_CODE (inner))
7031 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
7033 inner = TREE_OPERAND (inner, 0);
7037 /* If the second operand of the MINUS_EXPR has a pointer
7038 type (or is converted from it), this may be valid, so
7039 don't give a warning. */
7041 tree op1 = TREE_OPERAND (inner, 1);
7043 while (! POINTER_TYPE_P (TREE_TYPE (op1))
7044 && (TREE_CODE (op1) == NOP_EXPR
7045 || TREE_CODE (op1) == NON_LVALUE_EXPR
7046 || TREE_CODE (op1) == CONVERT_EXPR))
7047 op1 = TREE_OPERAND (op1, 0);
7049 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7052 inner = TREE_OPERAND (inner, 0);
7057 inner = TREE_OPERAND (inner, 0);
7059 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7060 inner = TREE_OPERAND (inner, 0);
7062 if (TREE_CODE (inner) == VAR_DECL
7063 && ! DECL_EXTERNAL (inner)
7064 && ! TREE_STATIC (inner)
7065 && DECL_CONTEXT (inner) == current_function_decl)
7066 warning ("function returns address of local variable");
7076 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7077 current_function_returns_value = 1;
7080 return add_stmt (build_return_stmt (retval));
7084 /* The SWITCH_STMT being built. */
7086 /* A splay-tree mapping the low element of a case range to the high
7087 element, or NULL_TREE if there is no high element. Used to
7088 determine whether or not a new case label duplicates an old case
7089 label. We need a tree, rather than simply a hash table, because
7090 of the GNU case range extension. */
7092 /* The next node on the stack. */
7093 struct c_switch *next;
7096 /* A stack of the currently active switch statements. The innermost
7097 switch statement is on the top of the stack. There is no need to
7098 mark the stack for garbage collection because it is only active
7099 during the processing of the body of a function, and we never
7100 collect at that point. */
7102 static struct c_switch *switch_stack;
7104 /* Start a C switch statement, testing expression EXP. Return the new
7111 enum tree_code code;
7113 struct c_switch *cs;
7115 if (exp != error_mark_node)
7117 code = TREE_CODE (TREE_TYPE (exp));
7118 type = TREE_TYPE (exp);
7120 if (! INTEGRAL_TYPE_P (type)
7121 && code != ERROR_MARK)
7123 error ("switch quantity not an integer");
7124 exp = integer_zero_node;
7129 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7131 if (warn_traditional && !in_system_header
7132 && (type == long_integer_type_node
7133 || type == long_unsigned_type_node))
7134 warning ("`long' switch expression not converted to `int' in ISO C");
7136 exp = default_conversion (exp);
7137 type = TREE_TYPE (exp);
7138 index = get_unwidened (exp, NULL_TREE);
7139 /* We can't strip a conversion from a signed type to an
7140 unsigned, because if we did, int_fits_type_p would do the
7141 wrong thing when checking case values for being in range,
7142 and it's too hard to do the right thing. */
7143 if (TREE_UNSIGNED (TREE_TYPE (exp))
7144 == TREE_UNSIGNED (TREE_TYPE (index)))
7149 /* Add this new SWITCH_STMT to the stack. */
7150 cs = (struct c_switch *) xmalloc (sizeof (*cs));
7151 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7152 cs->cases = splay_tree_new (case_compare, NULL, NULL);
7153 cs->next = switch_stack;
7156 return add_stmt (switch_stack->switch_stmt);
7159 /* Process a case label. */
7162 do_case (low_value, high_value)
7166 tree label = NULL_TREE;
7170 label = c_add_case_label (switch_stack->cases,
7171 SWITCH_COND (switch_stack->switch_stmt),
7172 low_value, high_value);
7173 if (label == error_mark_node)
7177 error ("case label not within a switch statement");
7179 error ("`default' label not within a switch statement");
7184 /* Finish the switch statement. */
7189 struct c_switch *cs = switch_stack;
7191 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7193 /* Pop the stack. */
7194 switch_stack = switch_stack->next;
7195 splay_tree_delete (cs->cases);