1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002 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_diff PARAMS ((tree, tree));
62 static tree unary_complex_lvalue PARAMS ((enum tree_code, tree, int));
63 static void pedantic_lvalue_warning PARAMS ((enum tree_code));
64 static tree internal_build_compound_expr PARAMS ((tree, int));
65 static tree convert_for_assignment PARAMS ((tree, tree, const char *,
67 static void warn_for_assignment PARAMS ((const char *, const char *,
69 static tree valid_compound_expr_initializer PARAMS ((tree, tree));
70 static void push_string PARAMS ((const char *));
71 static void push_member_name PARAMS ((tree));
72 static void push_array_bounds PARAMS ((int));
73 static int spelling_length PARAMS ((void));
74 static char *print_spelling PARAMS ((char *));
75 static void warning_init PARAMS ((const char *));
76 static tree digest_init PARAMS ((tree, tree, int, int));
77 static void output_init_element PARAMS ((tree, tree, tree, int));
78 static void output_pending_init_elements PARAMS ((int));
79 static int set_designator PARAMS ((int));
80 static void push_range_stack PARAMS ((tree));
81 static void add_pending_init PARAMS ((tree, tree));
82 static void set_nonincremental_init PARAMS ((void));
83 static void set_nonincremental_init_from_string PARAMS ((tree));
84 static tree find_init_member PARAMS ((tree));
86 /* Do `exp = require_complete_type (exp);' to make sure exp
87 does not have an incomplete type. (That includes void types.) */
90 require_complete_type (value)
93 tree type = TREE_TYPE (value);
95 if (value == error_mark_node || type == error_mark_node)
96 return error_mark_node;
98 /* First, detect a valid value with a complete type. */
99 if (COMPLETE_TYPE_P (type))
102 incomplete_type_error (value, type);
103 return error_mark_node;
106 /* Print an error message for invalid use of an incomplete type.
107 VALUE is the expression that was used (or 0 if that isn't known)
108 and TYPE is the type that was invalid. */
111 incomplete_type_error (value, type)
115 const char *type_code_string;
117 /* Avoid duplicate error message. */
118 if (TREE_CODE (type) == ERROR_MARK)
121 if (value != 0 && (TREE_CODE (value) == VAR_DECL
122 || TREE_CODE (value) == PARM_DECL))
123 error ("`%s' has an incomplete type",
124 IDENTIFIER_POINTER (DECL_NAME (value)));
128 /* We must print an error message. Be clever about what it says. */
130 switch (TREE_CODE (type))
133 type_code_string = "struct";
137 type_code_string = "union";
141 type_code_string = "enum";
145 error ("invalid use of void expression");
149 if (TYPE_DOMAIN (type))
151 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
153 error ("invalid use of flexible array member");
156 type = TREE_TYPE (type);
159 error ("invalid use of array with unspecified bounds");
166 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
167 error ("invalid use of undefined type `%s %s'",
168 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
170 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
171 error ("invalid use of incomplete typedef `%s'",
172 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
176 /* Return a variant of TYPE which has all the type qualifiers of LIKE
177 as well as those of TYPE. */
180 qualify_type (type, like)
183 return c_build_qualified_type (type,
184 TYPE_QUALS (type) | TYPE_QUALS (like));
187 /* Return the common type of two types.
188 We assume that comptypes has already been done and returned 1;
189 if that isn't so, this may crash. In particular, we assume that qualifiers
192 This is the type for the result of most arithmetic operations
193 if the operands have the given two types. */
199 enum tree_code code1;
200 enum tree_code code2;
203 /* Save time if the two types are the same. */
205 if (t1 == t2) return t1;
207 /* If one type is nonsense, use the other. */
208 if (t1 == error_mark_node)
210 if (t2 == error_mark_node)
213 /* Merge the attributes. */
214 attributes = (*targetm.merge_type_attributes) (t1, t2);
216 /* Treat an enum type as the unsigned integer type of the same width. */
218 if (TREE_CODE (t1) == ENUMERAL_TYPE)
219 t1 = type_for_size (TYPE_PRECISION (t1), 1);
220 if (TREE_CODE (t2) == ENUMERAL_TYPE)
221 t2 = type_for_size (TYPE_PRECISION (t2), 1);
223 code1 = TREE_CODE (t1);
224 code2 = TREE_CODE (t2);
226 /* If one type is complex, form the common type of the non-complex
227 components, then make that complex. Use T1 or T2 if it is the
229 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
231 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
232 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
233 tree subtype = common_type (subtype1, subtype2);
235 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
236 return build_type_attribute_variant (t1, attributes);
237 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
238 return build_type_attribute_variant (t2, attributes);
240 return build_type_attribute_variant (build_complex_type (subtype),
248 /* If only one is real, use it as the result. */
250 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
251 return build_type_attribute_variant (t1, attributes);
253 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
254 return build_type_attribute_variant (t2, attributes);
256 /* Both real or both integers; use the one with greater precision. */
258 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
259 return build_type_attribute_variant (t1, attributes);
260 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
261 return build_type_attribute_variant (t2, attributes);
263 /* Same precision. Prefer longs to ints even when same size. */
265 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
266 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
267 return build_type_attribute_variant (long_unsigned_type_node,
270 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
271 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
273 /* But preserve unsignedness from the other type,
274 since long cannot hold all the values of an unsigned int. */
275 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
276 t1 = long_unsigned_type_node;
278 t1 = long_integer_type_node;
279 return build_type_attribute_variant (t1, attributes);
282 /* Likewise, prefer long double to double even if same size. */
283 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
284 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
285 return build_type_attribute_variant (long_double_type_node,
288 /* Otherwise prefer the unsigned one. */
290 if (TREE_UNSIGNED (t1))
291 return build_type_attribute_variant (t1, attributes);
293 return build_type_attribute_variant (t2, attributes);
296 /* For two pointers, do this recursively on the target type,
297 and combine the qualifiers of the two types' targets. */
298 /* This code was turned off; I don't know why.
299 But ANSI C specifies doing this with the qualifiers.
300 So I turned it on again. */
302 tree pointed_to_1 = TREE_TYPE (t1);
303 tree pointed_to_2 = TREE_TYPE (t2);
304 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
305 TYPE_MAIN_VARIANT (pointed_to_2));
306 t1 = build_pointer_type (c_build_qualified_type
308 TYPE_QUALS (pointed_to_1) |
309 TYPE_QUALS (pointed_to_2)));
310 return build_type_attribute_variant (t1, attributes);
313 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
314 return build_type_attribute_variant (t1, attributes);
319 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
320 /* Save space: see if the result is identical to one of the args. */
321 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
322 return build_type_attribute_variant (t1, attributes);
323 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
324 return build_type_attribute_variant (t2, attributes);
325 /* Merge the element types, and have a size if either arg has one. */
326 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
327 return build_type_attribute_variant (t1, attributes);
331 /* Function types: prefer the one that specified arg types.
332 If both do, merge the arg types. Also merge the return types. */
334 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
335 tree p1 = TYPE_ARG_TYPES (t1);
336 tree p2 = TYPE_ARG_TYPES (t2);
341 /* Save space: see if the result is identical to one of the args. */
342 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
343 return build_type_attribute_variant (t1, attributes);
344 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
345 return build_type_attribute_variant (t2, attributes);
347 /* Simple way if one arg fails to specify argument types. */
348 if (TYPE_ARG_TYPES (t1) == 0)
350 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
351 return build_type_attribute_variant (t1, attributes);
353 if (TYPE_ARG_TYPES (t2) == 0)
355 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
356 return build_type_attribute_variant (t1, attributes);
359 /* If both args specify argument types, we must merge the two
360 lists, argument by argument. */
363 declare_parm_level (1);
365 len = list_length (p1);
368 for (i = 0; i < len; i++)
369 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
374 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
376 /* A null type means arg type is not specified.
377 Take whatever the other function type has. */
378 if (TREE_VALUE (p1) == 0)
380 TREE_VALUE (n) = TREE_VALUE (p2);
383 if (TREE_VALUE (p2) == 0)
385 TREE_VALUE (n) = TREE_VALUE (p1);
389 /* Given wait (union {union wait *u; int *i} *)
390 and wait (union wait *),
391 prefer union wait * as type of parm. */
392 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
393 && TREE_VALUE (p1) != TREE_VALUE (p2))
396 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
397 memb; memb = TREE_CHAIN (memb))
398 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
400 TREE_VALUE (n) = TREE_VALUE (p2);
402 pedwarn ("function types not truly compatible in ISO C");
406 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
407 && TREE_VALUE (p2) != TREE_VALUE (p1))
410 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
411 memb; memb = TREE_CHAIN (memb))
412 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
414 TREE_VALUE (n) = TREE_VALUE (p1);
416 pedwarn ("function types not truly compatible in ISO C");
420 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
426 t1 = build_function_type (valtype, newargs);
427 /* ... falls through ... */
431 return build_type_attribute_variant (t1, attributes);
436 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
437 or various other operations. Return 2 if they are compatible
438 but a warning may be needed if you use them together. */
441 comptypes (type1, type2)
448 /* Suppress errors caused by previously reported errors. */
450 if (t1 == t2 || !t1 || !t2
451 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
454 /* If either type is the internal version of sizetype, return the
456 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
457 && TYPE_DOMAIN (t1) != 0)
458 t1 = TYPE_DOMAIN (t1);
460 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
461 && TYPE_DOMAIN (t2) != 0)
462 t2 = TYPE_DOMAIN (t2);
464 /* Treat an enum type as the integer type of the same width and
467 if (TREE_CODE (t1) == ENUMERAL_TYPE)
468 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
469 if (TREE_CODE (t2) == ENUMERAL_TYPE)
470 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
475 /* Different classes of types can't be compatible. */
477 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
479 /* Qualifiers must match. */
481 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
484 /* Allow for two different type nodes which have essentially the same
485 definition. Note that we already checked for equality of the type
486 qualifiers (just above). */
488 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
491 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
492 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
495 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
498 switch (TREE_CODE (t1))
501 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
502 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
506 val = function_types_compatible_p (t1, t2);
511 tree d1 = TYPE_DOMAIN (t1);
512 tree d2 = TYPE_DOMAIN (t2);
513 bool d1_variable, d2_variable;
514 bool d1_zero, d2_zero;
517 /* Target types must match incl. qualifiers. */
518 if (TREE_TYPE (t1) != TREE_TYPE (t2)
519 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
522 /* Sizes must match unless one is missing or variable. */
523 if (d1 == 0 || d2 == 0 || d1 == d2)
526 d1_zero = ! TYPE_MAX_VALUE (d1);
527 d2_zero = ! TYPE_MAX_VALUE (d2);
529 d1_variable = (! d1_zero
530 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
531 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
532 d2_variable = (! d2_zero
533 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
534 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
536 if (d1_variable || d2_variable)
538 if (d1_zero && d2_zero)
540 if (d1_zero || d2_zero
541 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
542 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
549 if (maybe_objc_comptypes (t1, t2, 0) == 1)
556 return attrval == 2 && val == 1 ? 2 : val;
559 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
560 ignoring their qualifiers. */
563 comp_target_types (ttl, ttr)
568 /* Give maybe_objc_comptypes a crack at letting these types through. */
569 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
572 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
573 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
575 if (val == 2 && pedantic)
576 pedwarn ("types are not quite compatible");
580 /* Subroutines of `comptypes'. */
582 /* Return 1 if two function types F1 and F2 are compatible.
583 If either type specifies no argument types,
584 the other must specify a fixed number of self-promoting arg types.
585 Otherwise, if one type specifies only the number of arguments,
586 the other must specify that number of self-promoting arg types.
587 Otherwise, the argument types must match. */
590 function_types_compatible_p (f1, f2)
594 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
598 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
599 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
602 args1 = TYPE_ARG_TYPES (f1);
603 args2 = TYPE_ARG_TYPES (f2);
605 /* An unspecified parmlist matches any specified parmlist
606 whose argument types don't need default promotions. */
610 if (!self_promoting_args_p (args2))
612 /* If one of these types comes from a non-prototype fn definition,
613 compare that with the other type's arglist.
614 If they don't match, ask for a warning (but no error). */
615 if (TYPE_ACTUAL_ARG_TYPES (f1)
616 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
622 if (!self_promoting_args_p (args1))
624 if (TYPE_ACTUAL_ARG_TYPES (f2)
625 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
630 /* Both types have argument lists: compare them and propagate results. */
631 val1 = type_lists_compatible_p (args1, args2);
632 return val1 != 1 ? val1 : val;
635 /* Check two lists of types for compatibility,
636 returning 0 for incompatible, 1 for compatible,
637 or 2 for compatible with warning. */
640 type_lists_compatible_p (args1, args2)
643 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
649 if (args1 == 0 && args2 == 0)
651 /* If one list is shorter than the other,
652 they fail to match. */
653 if (args1 == 0 || args2 == 0)
655 /* A null pointer instead of a type
656 means there is supposed to be an argument
657 but nothing is specified about what type it has.
658 So match anything that self-promotes. */
659 if (TREE_VALUE (args1) == 0)
661 if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE)
664 else if (TREE_VALUE (args2) == 0)
666 if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE)
669 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
670 TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
672 /* Allow wait (union {union wait *u; int *i} *)
673 and wait (union wait *) to be compatible. */
674 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
675 && (TYPE_NAME (TREE_VALUE (args1)) == 0
676 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
677 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
678 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
679 TYPE_SIZE (TREE_VALUE (args2))))
682 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
683 memb; memb = TREE_CHAIN (memb))
684 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
689 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
690 && (TYPE_NAME (TREE_VALUE (args2)) == 0
691 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
692 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
693 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
694 TYPE_SIZE (TREE_VALUE (args1))))
697 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
698 memb; memb = TREE_CHAIN (memb))
699 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
708 /* comptypes said ok, but record if it said to warn. */
712 args1 = TREE_CHAIN (args1);
713 args2 = TREE_CHAIN (args2);
717 /* Compute the value of the `sizeof' operator. */
723 enum tree_code code = TREE_CODE (type);
726 if (code == FUNCTION_TYPE)
728 if (pedantic || warn_pointer_arith)
729 pedwarn ("sizeof applied to a function type");
730 size = size_one_node;
732 else if (code == VOID_TYPE)
734 if (pedantic || warn_pointer_arith)
735 pedwarn ("sizeof applied to a void type");
736 size = size_one_node;
738 else if (code == ERROR_MARK)
739 size = size_one_node;
740 else if (!COMPLETE_TYPE_P (type))
742 error ("sizeof applied to an incomplete type");
743 size = size_zero_node;
746 /* Convert in case a char is more than one unit. */
747 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
748 size_int (TYPE_PRECISION (char_type_node)
751 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
752 TYPE_IS_SIZETYPE means that certain things (like overflow) will
753 never happen. However, this node should really have type
754 `size_t', which is just a typedef for an ordinary integer type. */
755 return fold (build1 (NOP_EXPR, c_size_type_node, size));
759 c_sizeof_nowarn (type)
762 enum tree_code code = TREE_CODE (type);
765 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
766 size = size_one_node;
767 else if (!COMPLETE_TYPE_P (type))
768 size = size_zero_node;
770 /* Convert in case a char is more than one unit. */
771 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
772 size_int (TYPE_PRECISION (char_type_node)
775 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
776 TYPE_IS_SIZETYPE means that certain things (like overflow) will
777 never happen. However, this node should really have type
778 `size_t', which is just a typedef for an ordinary integer type. */
779 return fold (build1 (NOP_EXPR, c_size_type_node, size));
782 /* Compute the size to increment a pointer by. */
785 c_size_in_bytes (type)
788 enum tree_code code = TREE_CODE (type);
790 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
791 return size_one_node;
793 if (!COMPLETE_OR_VOID_TYPE_P (type))
795 error ("arithmetic on pointer to an incomplete type");
796 return size_one_node;
799 /* Convert in case a char is more than one unit. */
800 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
801 size_int (TYPE_PRECISION (char_type_node)
805 /* Return either DECL or its known constant value (if it has one). */
808 decl_constant_value (decl)
811 if (/* Don't change a variable array bound or initial value to a constant
812 in a place where a variable is invalid. */
813 current_function_decl != 0
814 && ! TREE_THIS_VOLATILE (decl)
815 && TREE_READONLY (decl)
816 && DECL_INITIAL (decl) != 0
817 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
818 /* This is invalid if initial value is not constant.
819 If it has either a function call, a memory reference,
820 or a variable, then re-evaluating it could give different results. */
821 && TREE_CONSTANT (DECL_INITIAL (decl))
822 /* Check for cases where this is sub-optimal, even though valid. */
823 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
824 return DECL_INITIAL (decl);
828 /* Return either DECL or its known constant value (if it has one), but
829 return DECL if pedantic or DECL has mode BLKmode. This is for
830 bug-compatibility with the old behavior of decl_constant_value
831 (before GCC 3.0); every use of this function is a bug and it should
832 be removed before GCC 3.1. It is not appropriate to use pedantic
833 in a way that affects optimization, and BLKmode is probably not the
834 right test for avoiding misoptimizations either. */
837 decl_constant_value_for_broken_optimization (decl)
840 if (pedantic || DECL_MODE (decl) == BLKmode)
843 return decl_constant_value (decl);
847 /* Perform the default conversion of arrays and functions to pointers.
848 Return the result of converting EXP. For any other expression, just
852 default_function_array_conversion (exp)
856 tree type = TREE_TYPE (exp);
857 enum tree_code code = TREE_CODE (type);
860 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
863 Do not use STRIP_NOPS here! It will remove conversions from pointer
864 to integer and cause infinite recursion. */
866 while (TREE_CODE (exp) == NON_LVALUE_EXPR
867 || (TREE_CODE (exp) == NOP_EXPR
868 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
870 if (TREE_CODE (exp) == NON_LVALUE_EXPR)
872 exp = TREE_OPERAND (exp, 0);
875 /* Preserve the original expression code. */
876 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
877 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
879 if (code == FUNCTION_TYPE)
881 return build_unary_op (ADDR_EXPR, exp, 0);
883 if (code == ARRAY_TYPE)
886 tree restype = TREE_TYPE (type);
892 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
894 constp = TREE_READONLY (exp);
895 volatilep = TREE_THIS_VOLATILE (exp);
898 if (TYPE_QUALS (type) || constp || volatilep)
900 = c_build_qualified_type (restype,
902 | (constp * TYPE_QUAL_CONST)
903 | (volatilep * TYPE_QUAL_VOLATILE));
905 if (TREE_CODE (exp) == INDIRECT_REF)
906 return convert (TYPE_POINTER_TO (restype),
907 TREE_OPERAND (exp, 0));
909 if (TREE_CODE (exp) == COMPOUND_EXPR)
911 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
912 return build (COMPOUND_EXPR, TREE_TYPE (op1),
913 TREE_OPERAND (exp, 0), op1);
916 lvalue_array_p = !not_lvalue && lvalue_p (exp);
917 if (!flag_isoc99 && !lvalue_array_p)
919 /* Before C99, non-lvalue arrays do not decay to pointers.
920 Normally, using such an array would be invalid; but it can
921 be used correctly inside sizeof or as a statement expression.
922 Thus, do not give an error here; an error will result later. */
926 ptrtype = build_pointer_type (restype);
928 if (TREE_CODE (exp) == VAR_DECL)
930 /* ??? This is not really quite correct
931 in that the type of the operand of ADDR_EXPR
932 is not the target type of the type of the ADDR_EXPR itself.
933 Question is, can this lossage be avoided? */
934 adr = build1 (ADDR_EXPR, ptrtype, exp);
935 if (mark_addressable (exp) == 0)
936 return error_mark_node;
937 TREE_CONSTANT (adr) = staticp (exp);
938 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
941 /* This way is better for a COMPONENT_REF since it can
942 simplify the offset for a component. */
943 adr = build_unary_op (ADDR_EXPR, exp, 1);
944 return convert (ptrtype, adr);
949 /* Perform default promotions for C data used in expressions.
950 Arrays and functions are converted to pointers;
951 enumeral types or short or char, to int.
952 In addition, manifest constants symbols are replaced by their values. */
955 default_conversion (exp)
959 tree type = TREE_TYPE (exp);
960 enum tree_code code = TREE_CODE (type);
962 if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
963 return default_function_array_conversion (exp);
965 /* Constants can be used directly unless they're not loadable. */
966 if (TREE_CODE (exp) == CONST_DECL)
967 exp = DECL_INITIAL (exp);
969 /* Replace a nonvolatile const static variable with its value unless
970 it is an array, in which case we must be sure that taking the
971 address of the array produces consistent results. */
972 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
974 exp = decl_constant_value_for_broken_optimization (exp);
975 type = TREE_TYPE (exp);
978 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
981 Do not use STRIP_NOPS here! It will remove conversions from pointer
982 to integer and cause infinite recursion. */
984 while (TREE_CODE (exp) == NON_LVALUE_EXPR
985 || (TREE_CODE (exp) == NOP_EXPR
986 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
987 exp = TREE_OPERAND (exp, 0);
989 /* Preserve the original expression code. */
990 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
991 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
993 /* Normally convert enums to int,
994 but convert wide enums to something wider. */
995 if (code == ENUMERAL_TYPE)
997 type = type_for_size (MAX (TYPE_PRECISION (type),
998 TYPE_PRECISION (integer_type_node)),
1000 || (TYPE_PRECISION (type)
1001 >= TYPE_PRECISION (integer_type_node)))
1002 && TREE_UNSIGNED (type)));
1004 return convert (type, exp);
1007 if (TREE_CODE (exp) == COMPONENT_REF
1008 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1009 /* If it's thinner than an int, promote it like a
1010 c_promoting_integer_type_p, otherwise leave it alone. */
1011 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1012 TYPE_PRECISION (integer_type_node)))
1013 return convert (flag_traditional && TREE_UNSIGNED (type)
1014 ? unsigned_type_node : integer_type_node,
1017 if (c_promoting_integer_type_p (type))
1019 /* Traditionally, unsignedness is preserved in default promotions.
1020 Also preserve unsignedness if not really getting any wider. */
1021 if (TREE_UNSIGNED (type)
1022 && (flag_traditional
1023 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1024 return convert (unsigned_type_node, exp);
1026 return convert (integer_type_node, exp);
1029 if (flag_traditional && !flag_allow_single_precision
1030 && TYPE_MAIN_VARIANT (type) == float_type_node)
1031 return convert (double_type_node, exp);
1033 if (code == VOID_TYPE)
1035 error ("void value not ignored as it ought to be");
1036 return error_mark_node;
1041 /* Look up COMPONENT in a structure or union DECL.
1043 If the component name is not found, returns NULL_TREE. Otherwise,
1044 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1045 stepping down the chain to the component, which is in the last
1046 TREE_VALUE of the list. Normally the list is of length one, but if
1047 the component is embedded within (nested) anonymous structures or
1048 unions, the list steps down the chain to the component. */
1051 lookup_field (decl, component)
1052 tree decl, component;
1054 tree type = TREE_TYPE (decl);
1057 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1058 to the field elements. Use a binary search on this array to quickly
1059 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1060 will always be set for structures which have many elements. */
1062 if (TYPE_LANG_SPECIFIC (type))
1065 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1067 field = TYPE_FIELDS (type);
1069 top = TYPE_LANG_SPECIFIC (type)->len;
1070 while (top - bot > 1)
1072 half = (top - bot + 1) >> 1;
1073 field = field_array[bot+half];
1075 if (DECL_NAME (field) == NULL_TREE)
1077 /* Step through all anon unions in linear fashion. */
1078 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1080 field = field_array[bot++];
1081 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1082 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1084 tree anon = lookup_field (field, component);
1087 return tree_cons (NULL_TREE, field, anon);
1091 /* Entire record is only anon unions. */
1095 /* Restart the binary search, with new lower bound. */
1099 if (DECL_NAME (field) == component)
1101 if (DECL_NAME (field) < component)
1107 if (DECL_NAME (field_array[bot]) == component)
1108 field = field_array[bot];
1109 else if (DECL_NAME (field) != component)
1114 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1116 if (DECL_NAME (field) == NULL_TREE
1117 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1118 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1120 tree anon = lookup_field (field, component);
1123 return tree_cons (NULL_TREE, field, anon);
1126 if (DECL_NAME (field) == component)
1130 if (field == NULL_TREE)
1134 return tree_cons (NULL_TREE, field, NULL_TREE);
1137 /* Make an expression to refer to the COMPONENT field of
1138 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1141 build_component_ref (datum, component)
1142 tree datum, component;
1144 tree type = TREE_TYPE (datum);
1145 enum tree_code code = TREE_CODE (type);
1149 /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
1150 If pedantic ensure that the arguments are not lvalues; otherwise,
1151 if the component is an array, it would wrongly decay to a pointer in
1153 We cannot do this with a COND_EXPR, because in a conditional expression
1154 the default promotions are applied to both sides, and this would yield
1155 the wrong type of the result; for example, if the components have
1157 switch (TREE_CODE (datum))
1161 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1162 return build (COMPOUND_EXPR, TREE_TYPE (value),
1163 TREE_OPERAND (datum, 0), pedantic_non_lvalue (value));
1169 /* See if there is a field or component with name COMPONENT. */
1171 if (code == RECORD_TYPE || code == UNION_TYPE)
1173 if (!COMPLETE_TYPE_P (type))
1175 incomplete_type_error (NULL_TREE, type);
1176 return error_mark_node;
1179 field = lookup_field (datum, component);
1183 error ("%s has no member named `%s'",
1184 code == RECORD_TYPE ? "structure" : "union",
1185 IDENTIFIER_POINTER (component));
1186 return error_mark_node;
1189 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1190 This might be better solved in future the way the C++ front
1191 end does it - by giving the anonymous entities each a
1192 separate name and type, and then have build_component_ref
1193 recursively call itself. We can't do that here. */
1194 for (; field; field = TREE_CHAIN (field))
1196 tree subdatum = TREE_VALUE (field);
1198 if (TREE_TYPE (subdatum) == error_mark_node)
1199 return error_mark_node;
1201 ref = build (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum);
1202 if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1203 TREE_READONLY (ref) = 1;
1204 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1205 TREE_THIS_VOLATILE (ref) = 1;
1207 if (TREE_DEPRECATED (subdatum))
1208 warn_deprecated_use (subdatum);
1215 else if (code != ERROR_MARK)
1216 error ("request for member `%s' in something not a structure or union",
1217 IDENTIFIER_POINTER (component));
1219 return error_mark_node;
1222 /* Given an expression PTR for a pointer, return an expression
1223 for the value pointed to.
1224 ERRORSTRING is the name of the operator to appear in error messages. */
1227 build_indirect_ref (ptr, errorstring)
1229 const char *errorstring;
1231 tree pointer = default_conversion (ptr);
1232 tree type = TREE_TYPE (pointer);
1234 if (TREE_CODE (type) == POINTER_TYPE)
1236 if (TREE_CODE (pointer) == ADDR_EXPR
1238 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1239 == TREE_TYPE (type)))
1240 return TREE_OPERAND (pointer, 0);
1243 tree t = TREE_TYPE (type);
1244 tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1246 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1248 error ("dereferencing pointer to incomplete type");
1249 return error_mark_node;
1251 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1252 warning ("dereferencing `void *' pointer");
1254 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1255 so that we get the proper error message if the result is used
1256 to assign to. Also, &* is supposed to be a no-op.
1257 And ANSI C seems to specify that the type of the result
1258 should be the const type. */
1259 /* A de-reference of a pointer to const is not a const. It is valid
1260 to change it via some other pointer. */
1261 TREE_READONLY (ref) = TYPE_READONLY (t);
1262 TREE_SIDE_EFFECTS (ref)
1263 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1264 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1268 else if (TREE_CODE (pointer) != ERROR_MARK)
1269 error ("invalid type argument of `%s'", errorstring);
1270 return error_mark_node;
1273 /* This handles expressions of the form "a[i]", which denotes
1276 This is logically equivalent in C to *(a+i), but we may do it differently.
1277 If A is a variable or a member, we generate a primitive ARRAY_REF.
1278 This avoids forcing the array out of registers, and can work on
1279 arrays that are not lvalues (for example, members of structures returned
1283 build_array_ref (array, index)
1288 error ("subscript missing in array reference");
1289 return error_mark_node;
1292 if (TREE_TYPE (array) == error_mark_node
1293 || TREE_TYPE (index) == error_mark_node)
1294 return error_mark_node;
1296 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1297 && TREE_CODE (array) != INDIRECT_REF)
1301 /* Subscripting with type char is likely to lose
1302 on a machine where chars are signed.
1303 So warn on any machine, but optionally.
1304 Don't warn for unsigned char since that type is safe.
1305 Don't warn for signed char because anyone who uses that
1306 must have done so deliberately. */
1307 if (warn_char_subscripts
1308 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1309 warning ("array subscript has type `char'");
1311 /* Apply default promotions *after* noticing character types. */
1312 index = default_conversion (index);
1314 /* Require integer *after* promotion, for sake of enums. */
1315 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1317 error ("array subscript is not an integer");
1318 return error_mark_node;
1321 /* An array that is indexed by a non-constant
1322 cannot be stored in a register; we must be able to do
1323 address arithmetic on its address.
1324 Likewise an array of elements of variable size. */
1325 if (TREE_CODE (index) != INTEGER_CST
1326 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1327 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1329 if (mark_addressable (array) == 0)
1330 return error_mark_node;
1332 /* An array that is indexed by a constant value which is not within
1333 the array bounds cannot be stored in a register either; because we
1334 would get a crash in store_bit_field/extract_bit_field when trying
1335 to access a non-existent part of the register. */
1336 if (TREE_CODE (index) == INTEGER_CST
1337 && TYPE_VALUES (TREE_TYPE (array))
1338 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1340 if (mark_addressable (array) == 0)
1341 return error_mark_node;
1347 while (TREE_CODE (foo) == COMPONENT_REF)
1348 foo = TREE_OPERAND (foo, 0);
1349 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1350 pedwarn ("ISO C forbids subscripting `register' array");
1351 else if (! flag_isoc99 && ! lvalue_p (foo))
1352 pedwarn ("ISO C89 forbids subscripting non-lvalue array");
1355 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1356 rval = build (ARRAY_REF, type, array, index);
1357 /* Array ref is const/volatile if the array elements are
1358 or if the array is. */
1359 TREE_READONLY (rval)
1360 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1361 | TREE_READONLY (array));
1362 TREE_SIDE_EFFECTS (rval)
1363 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1364 | TREE_SIDE_EFFECTS (array));
1365 TREE_THIS_VOLATILE (rval)
1366 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1367 /* This was added by rms on 16 Nov 91.
1368 It fixes vol struct foo *a; a->elts[1]
1369 in an inline function.
1370 Hope it doesn't break something else. */
1371 | TREE_THIS_VOLATILE (array));
1372 return require_complete_type (fold (rval));
1376 tree ar = default_conversion (array);
1377 tree ind = default_conversion (index);
1379 /* Do the same warning check as above, but only on the part that's
1380 syntactically the index and only if it is also semantically
1382 if (warn_char_subscripts
1383 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1384 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1385 warning ("subscript has type `char'");
1387 /* Put the integer in IND to simplify error checking. */
1388 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1395 if (ar == error_mark_node)
1398 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1399 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1401 error ("subscripted value is neither array nor pointer");
1402 return error_mark_node;
1404 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1406 error ("array subscript is not an integer");
1407 return error_mark_node;
1410 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1415 /* Build an external reference to identifier ID. FUN indicates
1416 whether this will be used for a function call. */
1418 build_external_ref (id, fun)
1423 tree decl = lookup_name (id);
1424 tree objc_ivar = lookup_objc_ivar (id);
1426 if (decl && TREE_DEPRECATED (decl))
1427 warn_deprecated_use (decl);
1429 if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
1435 if (!decl || decl == error_mark_node)
1436 /* Ordinary implicit function declaration. */
1437 ref = implicitly_declare (id);
1440 /* Implicit declaration of built-in function. Don't
1441 change the built-in declaration, but don't let this
1442 go by silently, either. */
1443 implicit_decl_warning (id);
1445 /* only issue this warning once */
1446 C_DECL_ANTICIPATED (decl) = 0;
1452 /* Reference to undeclared variable, including reference to
1453 builtin outside of function-call context. */
1454 if (current_function_decl == 0)
1455 error ("`%s' undeclared here (not in a function)",
1456 IDENTIFIER_POINTER (id));
1459 if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node
1460 || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl)
1462 error ("`%s' undeclared (first use in this function)",
1463 IDENTIFIER_POINTER (id));
1465 if (! undeclared_variable_notice)
1467 error ("(Each undeclared identifier is reported only once");
1468 error ("for each function it appears in.)");
1469 undeclared_variable_notice = 1;
1472 IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node;
1473 IDENTIFIER_ERROR_LOCUS (id) = current_function_decl;
1475 return error_mark_node;
1480 /* Properly declared variable or function reference. */
1483 else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
1485 warning ("local declaration of `%s' hides instance variable",
1486 IDENTIFIER_POINTER (id));
1493 if (TREE_TYPE (ref) == error_mark_node)
1494 return error_mark_node;
1496 if (!skip_evaluation)
1497 assemble_external (ref);
1498 TREE_USED (ref) = 1;
1500 if (TREE_CODE (ref) == CONST_DECL)
1502 ref = DECL_INITIAL (ref);
1503 TREE_CONSTANT (ref) = 1;
1509 /* Build a function call to function FUNCTION with parameters PARAMS.
1510 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1511 TREE_VALUE of each node is a parameter-expression.
1512 FUNCTION's data type may be a function type or a pointer-to-function. */
1515 build_function_call (function, params)
1516 tree function, params;
1518 tree fntype, fundecl = 0;
1519 tree coerced_params;
1520 tree name = NULL_TREE, assembler_name = NULL_TREE, result;
1522 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1523 STRIP_TYPE_NOPS (function);
1525 /* Convert anything with function type to a pointer-to-function. */
1526 if (TREE_CODE (function) == FUNCTION_DECL)
1528 name = DECL_NAME (function);
1529 assembler_name = DECL_ASSEMBLER_NAME (function);
1531 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1532 (because calling an inline function does not mean the function
1533 needs to be separately compiled). */
1534 fntype = build_type_variant (TREE_TYPE (function),
1535 TREE_READONLY (function),
1536 TREE_THIS_VOLATILE (function));
1538 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1541 function = default_conversion (function);
1543 fntype = TREE_TYPE (function);
1545 if (TREE_CODE (fntype) == ERROR_MARK)
1546 return error_mark_node;
1548 if (!(TREE_CODE (fntype) == POINTER_TYPE
1549 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1551 error ("called object is not a function");
1552 return error_mark_node;
1555 if (fundecl && TREE_THIS_VOLATILE (fundecl))
1556 current_function_returns_abnormally = 1;
1558 /* fntype now gets the type of function pointed to. */
1559 fntype = TREE_TYPE (fntype);
1561 /* Convert the parameters to the types declared in the
1562 function prototype, or apply default promotions. */
1565 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1567 /* Check for errors in format strings. */
1570 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
1572 /* Recognize certain built-in functions so we can make tree-codes
1573 other than CALL_EXPR. We do this when it enables fold-const.c
1574 to do something useful. */
1576 if (TREE_CODE (function) == ADDR_EXPR
1577 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1578 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1580 result = expand_tree_builtin (TREE_OPERAND (function, 0),
1581 params, coerced_params);
1586 result = build (CALL_EXPR, TREE_TYPE (fntype),
1587 function, coerced_params, NULL_TREE);
1588 TREE_SIDE_EFFECTS (result) = 1;
1589 result = fold (result);
1591 if (VOID_TYPE_P (TREE_TYPE (result)))
1593 return require_complete_type (result);
1596 /* Convert the argument expressions in the list VALUES
1597 to the types in the list TYPELIST. The result is a list of converted
1598 argument expressions.
1600 If TYPELIST is exhausted, or when an element has NULL as its type,
1601 perform the default conversions.
1603 PARMLIST is the chain of parm decls for the function being called.
1604 It may be 0, if that info is not available.
1605 It is used only for generating error messages.
1607 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1609 This is also where warnings about wrong number of args are generated.
1611 Both VALUES and the returned value are chains of TREE_LIST nodes
1612 with the elements of the list in the TREE_VALUE slots of those nodes. */
1615 convert_arguments (typelist, values, name, fundecl)
1616 tree typelist, values, name, fundecl;
1618 tree typetail, valtail;
1622 /* Scan the given expressions and types, producing individual
1623 converted arguments and pushing them on RESULT in reverse order. */
1625 for (valtail = values, typetail = typelist, parmnum = 0;
1627 valtail = TREE_CHAIN (valtail), parmnum++)
1629 tree type = typetail ? TREE_VALUE (typetail) : 0;
1630 tree val = TREE_VALUE (valtail);
1632 if (type == void_type_node)
1635 error ("too many arguments to function `%s'",
1636 IDENTIFIER_POINTER (name));
1638 error ("too many arguments to function");
1642 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1643 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1644 to convert automatically to a pointer. */
1645 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1646 val = TREE_OPERAND (val, 0);
1648 val = default_function_array_conversion (val);
1650 val = require_complete_type (val);
1654 /* Formal parm type is specified by a function prototype. */
1657 if (!COMPLETE_TYPE_P (type))
1659 error ("type of formal parameter %d is incomplete", parmnum + 1);
1664 /* Optionally warn about conversions that
1665 differ from the default conversions. */
1666 if (warn_conversion || warn_traditional)
1668 int formal_prec = TYPE_PRECISION (type);
1670 if (INTEGRAL_TYPE_P (type)
1671 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1672 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1673 if (INTEGRAL_TYPE_P (type)
1674 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1675 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1676 else if (TREE_CODE (type) == COMPLEX_TYPE
1677 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1678 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1679 else if (TREE_CODE (type) == REAL_TYPE
1680 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1681 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1682 else if (TREE_CODE (type) == COMPLEX_TYPE
1683 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1684 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1685 else if (TREE_CODE (type) == REAL_TYPE
1686 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1687 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1688 /* ??? At some point, messages should be written about
1689 conversions between complex types, but that's too messy
1691 else if (TREE_CODE (type) == REAL_TYPE
1692 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1694 /* Warn if any argument is passed as `float',
1695 since without a prototype it would be `double'. */
1696 if (formal_prec == TYPE_PRECISION (float_type_node))
1697 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1699 /* Detect integer changing in width or signedness.
1700 These warnings are only activated with
1701 -Wconversion, not with -Wtraditional. */
1702 else if (warn_conversion && INTEGRAL_TYPE_P (type)
1703 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1705 tree would_have_been = default_conversion (val);
1706 tree type1 = TREE_TYPE (would_have_been);
1708 if (TREE_CODE (type) == ENUMERAL_TYPE
1709 && (TYPE_MAIN_VARIANT (type)
1710 == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
1711 /* No warning if function asks for enum
1712 and the actual arg is that enum type. */
1714 else if (formal_prec != TYPE_PRECISION (type1))
1715 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1716 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1718 /* Don't complain if the formal parameter type
1719 is an enum, because we can't tell now whether
1720 the value was an enum--even the same enum. */
1721 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1723 else if (TREE_CODE (val) == INTEGER_CST
1724 && int_fits_type_p (val, type))
1725 /* Change in signedness doesn't matter
1726 if a constant value is unaffected. */
1728 /* Likewise for a constant in a NOP_EXPR. */
1729 else if (TREE_CODE (val) == NOP_EXPR
1730 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1731 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1733 #if 0 /* We never get such tree structure here. */
1734 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1735 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1736 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1737 /* Change in signedness doesn't matter
1738 if an enum value is unaffected. */
1741 /* If the value is extended from a narrower
1742 unsigned type, it doesn't matter whether we
1743 pass it as signed or unsigned; the value
1744 certainly is the same either way. */
1745 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1746 && TREE_UNSIGNED (TREE_TYPE (val)))
1748 else if (TREE_UNSIGNED (type))
1749 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1751 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1755 parmval = convert_for_assignment (type, val,
1756 (char *) 0, /* arg passing */
1757 fundecl, name, parmnum + 1);
1759 if (PROMOTE_PROTOTYPES
1760 && INTEGRAL_TYPE_P (type)
1761 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1762 parmval = default_conversion (parmval);
1764 result = tree_cons (NULL_TREE, parmval, result);
1766 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1767 && (TYPE_PRECISION (TREE_TYPE (val))
1768 < TYPE_PRECISION (double_type_node)))
1769 /* Convert `float' to `double'. */
1770 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1772 /* Convert `short' and `char' to full-size `int'. */
1773 result = tree_cons (NULL_TREE, default_conversion (val), result);
1776 typetail = TREE_CHAIN (typetail);
1779 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1782 error ("too few arguments to function `%s'",
1783 IDENTIFIER_POINTER (name));
1785 error ("too few arguments to function");
1788 return nreverse (result);
1791 /* This is the entry point used by the parser
1792 for binary operators in the input.
1793 In addition to constructing the expression,
1794 we check for operands that were written with other binary operators
1795 in a way that is likely to confuse the user. */
1798 parser_build_binary_op (code, arg1, arg2)
1799 enum tree_code code;
1802 tree result = build_binary_op (code, arg1, arg2, 1);
1805 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1806 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1807 enum tree_code code1 = ERROR_MARK;
1808 enum tree_code code2 = ERROR_MARK;
1810 if (TREE_CODE (result) == ERROR_MARK)
1811 return error_mark_node;
1813 if (IS_EXPR_CODE_CLASS (class1))
1814 code1 = C_EXP_ORIGINAL_CODE (arg1);
1815 if (IS_EXPR_CODE_CLASS (class2))
1816 code2 = C_EXP_ORIGINAL_CODE (arg2);
1818 /* Check for cases such as x+y<<z which users are likely
1819 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1820 is cleared to prevent these warnings. */
1821 if (warn_parentheses)
1823 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1825 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1826 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1827 warning ("suggest parentheses around + or - inside shift");
1830 if (code == TRUTH_ORIF_EXPR)
1832 if (code1 == TRUTH_ANDIF_EXPR
1833 || code2 == TRUTH_ANDIF_EXPR)
1834 warning ("suggest parentheses around && within ||");
1837 if (code == BIT_IOR_EXPR)
1839 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1840 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1841 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1842 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1843 warning ("suggest parentheses around arithmetic in operand of |");
1844 /* Check cases like x|y==z */
1845 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1846 warning ("suggest parentheses around comparison in operand of |");
1849 if (code == BIT_XOR_EXPR)
1851 if (code1 == BIT_AND_EXPR
1852 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1853 || code2 == BIT_AND_EXPR
1854 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1855 warning ("suggest parentheses around arithmetic in operand of ^");
1856 /* Check cases like x^y==z */
1857 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1858 warning ("suggest parentheses around comparison in operand of ^");
1861 if (code == BIT_AND_EXPR)
1863 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1864 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1865 warning ("suggest parentheses around + or - in operand of &");
1866 /* Check cases like x&y==z */
1867 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1868 warning ("suggest parentheses around comparison in operand of &");
1872 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1873 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1874 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1875 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1877 unsigned_conversion_warning (result, arg1);
1878 unsigned_conversion_warning (result, arg2);
1879 overflow_warning (result);
1881 class = TREE_CODE_CLASS (TREE_CODE (result));
1883 /* Record the code that was specified in the source,
1884 for the sake of warnings about confusing nesting. */
1885 if (IS_EXPR_CODE_CLASS (class))
1886 C_SET_EXP_ORIGINAL_CODE (result, code);
1889 int flag = TREE_CONSTANT (result);
1890 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1891 so that convert_for_assignment wouldn't strip it.
1892 That way, we got warnings for things like p = (1 - 1).
1893 But it turns out we should not get those warnings. */
1894 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1895 C_SET_EXP_ORIGINAL_CODE (result, code);
1896 TREE_CONSTANT (result) = flag;
1902 /* Build a binary-operation expression without default conversions.
1903 CODE is the kind of expression to build.
1904 This function differs from `build' in several ways:
1905 the data type of the result is computed and recorded in it,
1906 warnings are generated if arg data types are invalid,
1907 special handling for addition and subtraction of pointers is known,
1908 and some optimization is done (operations on narrow ints
1909 are done in the narrower type when that gives the same result).
1910 Constant folding is also done before the result is returned.
1912 Note that the operands will never have enumeral types, or function
1913 or array types, because either they will have the default conversions
1914 performed or they have both just been converted to some other type in which
1915 the arithmetic is to be done. */
1918 build_binary_op (code, orig_op0, orig_op1, convert_p)
1919 enum tree_code code;
1920 tree orig_op0, orig_op1;
1924 enum tree_code code0, code1;
1927 /* Expression code to give to the expression when it is built.
1928 Normally this is CODE, which is what the caller asked for,
1929 but in some special cases we change it. */
1930 enum tree_code resultcode = code;
1932 /* Data type in which the computation is to be performed.
1933 In the simplest cases this is the common type of the arguments. */
1934 tree result_type = NULL;
1936 /* Nonzero means operands have already been type-converted
1937 in whatever way is necessary.
1938 Zero means they need to be converted to RESULT_TYPE. */
1941 /* Nonzero means create the expression with this type, rather than
1943 tree build_type = 0;
1945 /* Nonzero means after finally constructing the expression
1946 convert it to this type. */
1947 tree final_type = 0;
1949 /* Nonzero if this is an operation like MIN or MAX which can
1950 safely be computed in short if both args are promoted shorts.
1951 Also implies COMMON.
1952 -1 indicates a bitwise operation; this makes a difference
1953 in the exact conditions for when it is safe to do the operation
1954 in a narrower mode. */
1957 /* Nonzero if this is a comparison operation;
1958 if both args are promoted shorts, compare the original shorts.
1959 Also implies COMMON. */
1960 int short_compare = 0;
1962 /* Nonzero if this is a right-shift operation, which can be computed on the
1963 original short and then promoted if the operand is a promoted short. */
1964 int short_shift = 0;
1966 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1971 op0 = default_conversion (orig_op0);
1972 op1 = default_conversion (orig_op1);
1980 type0 = TREE_TYPE (op0);
1981 type1 = TREE_TYPE (op1);
1983 /* The expression codes of the data types of the arguments tell us
1984 whether the arguments are integers, floating, pointers, etc. */
1985 code0 = TREE_CODE (type0);
1986 code1 = TREE_CODE (type1);
1988 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1989 STRIP_TYPE_NOPS (op0);
1990 STRIP_TYPE_NOPS (op1);
1992 /* If an error was already reported for one of the arguments,
1993 avoid reporting another error. */
1995 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
1996 return error_mark_node;
2001 /* Handle the pointer + int case. */
2002 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2003 return pointer_int_sum (PLUS_EXPR, op0, op1);
2004 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2005 return pointer_int_sum (PLUS_EXPR, op1, op0);
2011 /* Subtraction of two similar pointers.
2012 We must subtract them as integers, then divide by object size. */
2013 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2014 && comp_target_types (type0, type1))
2015 return pointer_diff (op0, op1);
2016 /* Handle pointer minus int. Just like pointer plus int. */
2017 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2018 return pointer_int_sum (MINUS_EXPR, op0, op1);
2027 case TRUNC_DIV_EXPR:
2029 case FLOOR_DIV_EXPR:
2030 case ROUND_DIV_EXPR:
2031 case EXACT_DIV_EXPR:
2032 /* Floating point division by zero is a legitimate way to obtain
2033 infinities and NaNs. */
2034 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2035 warning ("division by zero");
2037 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2038 || code0 == COMPLEX_TYPE)
2039 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2040 || code1 == COMPLEX_TYPE))
2042 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2043 resultcode = RDIV_EXPR;
2045 /* Although it would be tempting to shorten always here, that
2046 loses on some targets, since the modulo instruction is
2047 undefined if the quotient can't be represented in the
2048 computation mode. We shorten only if unsigned or if
2049 dividing by something we know != -1. */
2050 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2051 || (TREE_CODE (op1) == INTEGER_CST
2052 && ! integer_all_onesp (op1)));
2058 case BIT_ANDTC_EXPR:
2061 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2065 case TRUNC_MOD_EXPR:
2066 case FLOOR_MOD_EXPR:
2067 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2068 warning ("division by zero");
2070 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2072 /* Although it would be tempting to shorten always here, that loses
2073 on some targets, since the modulo instruction is undefined if the
2074 quotient can't be represented in the computation mode. We shorten
2075 only if unsigned or if dividing by something we know != -1. */
2076 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2077 || (TREE_CODE (op1) == INTEGER_CST
2078 && ! integer_all_onesp (op1)));
2083 case TRUTH_ANDIF_EXPR:
2084 case TRUTH_ORIF_EXPR:
2085 case TRUTH_AND_EXPR:
2087 case TRUTH_XOR_EXPR:
2088 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2089 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2090 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2091 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2093 /* Result of these operations is always an int,
2094 but that does not mean the operands should be
2095 converted to ints! */
2096 result_type = integer_type_node;
2097 op0 = truthvalue_conversion (op0);
2098 op1 = truthvalue_conversion (op1);
2103 /* Shift operations: result has same type as first operand;
2104 always convert second operand to int.
2105 Also set SHORT_SHIFT if shifting rightward. */
2108 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2110 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2112 if (tree_int_cst_sgn (op1) < 0)
2113 warning ("right shift count is negative");
2116 if (! integer_zerop (op1))
2119 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2120 warning ("right shift count >= width of type");
2124 /* Use the type of the value to be shifted.
2125 This is what most traditional C compilers do. */
2126 result_type = type0;
2127 /* Unless traditional, convert the shift-count to an integer,
2128 regardless of size of value being shifted. */
2129 if (! flag_traditional)
2131 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2132 op1 = convert (integer_type_node, op1);
2133 /* Avoid converting op1 to result_type later. */
2140 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2142 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2144 if (tree_int_cst_sgn (op1) < 0)
2145 warning ("left shift count is negative");
2147 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2148 warning ("left shift count >= width of type");
2151 /* Use the type of the value to be shifted.
2152 This is what most traditional C compilers do. */
2153 result_type = type0;
2154 /* Unless traditional, convert the shift-count to an integer,
2155 regardless of size of value being shifted. */
2156 if (! flag_traditional)
2158 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2159 op1 = convert (integer_type_node, op1);
2160 /* Avoid converting op1 to result_type later. */
2168 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2170 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2172 if (tree_int_cst_sgn (op1) < 0)
2173 warning ("shift count is negative");
2174 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2175 warning ("shift count >= width of type");
2178 /* Use the type of the value to be shifted.
2179 This is what most traditional C compilers do. */
2180 result_type = type0;
2181 /* Unless traditional, convert the shift-count to an integer,
2182 regardless of size of value being shifted. */
2183 if (! flag_traditional)
2185 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2186 op1 = convert (integer_type_node, op1);
2187 /* Avoid converting op1 to result_type later. */
2195 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2196 warning ("comparing floating point with == or != is unsafe");
2197 /* Result of comparison is always int,
2198 but don't convert the args to int! */
2199 build_type = integer_type_node;
2200 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2201 || code0 == COMPLEX_TYPE)
2202 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2203 || code1 == COMPLEX_TYPE))
2205 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2207 tree tt0 = TREE_TYPE (type0);
2208 tree tt1 = TREE_TYPE (type1);
2209 /* Anything compares with void *. void * compares with anything.
2210 Otherwise, the targets must be compatible
2211 and both must be object or both incomplete. */
2212 if (comp_target_types (type0, type1))
2213 result_type = common_type (type0, type1);
2214 else if (VOID_TYPE_P (tt0))
2216 /* op0 != orig_op0 detects the case of something
2217 whose value is 0 but which isn't a valid null ptr const. */
2218 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2219 && TREE_CODE (tt1) == FUNCTION_TYPE)
2220 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2222 else if (VOID_TYPE_P (tt1))
2224 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2225 && TREE_CODE (tt0) == FUNCTION_TYPE)
2226 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2229 pedwarn ("comparison of distinct pointer types lacks a cast");
2231 if (result_type == NULL_TREE)
2232 result_type = ptr_type_node;
2234 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2235 && integer_zerop (op1))
2236 result_type = type0;
2237 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2238 && integer_zerop (op0))
2239 result_type = type1;
2240 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2242 result_type = type0;
2243 if (! flag_traditional)
2244 pedwarn ("comparison between pointer and integer");
2246 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2248 result_type = type1;
2249 if (! flag_traditional)
2250 pedwarn ("comparison between pointer and integer");
2256 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2257 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2259 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2261 if (comp_target_types (type0, type1))
2263 result_type = common_type (type0, type1);
2265 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2266 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2270 result_type = ptr_type_node;
2271 pedwarn ("comparison of distinct pointer types lacks a cast");
2280 build_type = integer_type_node;
2281 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2282 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2284 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2286 if (comp_target_types (type0, type1))
2288 result_type = common_type (type0, type1);
2289 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2290 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2291 pedwarn ("comparison of complete and incomplete pointers");
2293 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2294 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2298 result_type = ptr_type_node;
2299 pedwarn ("comparison of distinct pointer types lacks a cast");
2302 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2303 && integer_zerop (op1))
2305 result_type = type0;
2306 if (pedantic || extra_warnings)
2307 pedwarn ("ordered comparison of pointer with integer zero");
2309 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2310 && integer_zerop (op0))
2312 result_type = type1;
2314 pedwarn ("ordered comparison of pointer with integer zero");
2316 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2318 result_type = type0;
2319 if (! flag_traditional)
2320 pedwarn ("comparison between pointer and integer");
2322 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2324 result_type = type1;
2325 if (! flag_traditional)
2326 pedwarn ("comparison between pointer and integer");
2330 case UNORDERED_EXPR:
2337 build_type = integer_type_node;
2338 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2340 error ("unordered comparison on non-floating point argument");
2341 return error_mark_node;
2350 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2352 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2354 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2356 if (shorten || common || short_compare)
2357 result_type = common_type (type0, type1);
2359 /* For certain operations (which identify themselves by shorten != 0)
2360 if both args were extended from the same smaller type,
2361 do the arithmetic in that type and then extend.
2363 shorten !=0 and !=1 indicates a bitwise operation.
2364 For them, this optimization is safe only if
2365 both args are zero-extended or both are sign-extended.
2366 Otherwise, we might change the result.
2367 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2368 but calculated in (unsigned short) it would be (unsigned short)-1. */
2370 if (shorten && none_complex)
2372 int unsigned0, unsigned1;
2373 tree arg0 = get_narrower (op0, &unsigned0);
2374 tree arg1 = get_narrower (op1, &unsigned1);
2375 /* UNS is 1 if the operation to be done is an unsigned one. */
2376 int uns = TREE_UNSIGNED (result_type);
2379 final_type = result_type;
2381 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2382 but it *requires* conversion to FINAL_TYPE. */
2384 if ((TYPE_PRECISION (TREE_TYPE (op0))
2385 == TYPE_PRECISION (TREE_TYPE (arg0)))
2386 && TREE_TYPE (op0) != final_type)
2387 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2388 if ((TYPE_PRECISION (TREE_TYPE (op1))
2389 == TYPE_PRECISION (TREE_TYPE (arg1)))
2390 && TREE_TYPE (op1) != final_type)
2391 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2393 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2395 /* For bitwise operations, signedness of nominal type
2396 does not matter. Consider only how operands were extended. */
2400 /* Note that in all three cases below we refrain from optimizing
2401 an unsigned operation on sign-extended args.
2402 That would not be valid. */
2404 /* Both args variable: if both extended in same way
2405 from same width, do it in that width.
2406 Do it unsigned if args were zero-extended. */
2407 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2408 < TYPE_PRECISION (result_type))
2409 && (TYPE_PRECISION (TREE_TYPE (arg1))
2410 == TYPE_PRECISION (TREE_TYPE (arg0)))
2411 && unsigned0 == unsigned1
2412 && (unsigned0 || !uns))
2414 = signed_or_unsigned_type (unsigned0,
2415 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2416 else if (TREE_CODE (arg0) == INTEGER_CST
2417 && (unsigned1 || !uns)
2418 && (TYPE_PRECISION (TREE_TYPE (arg1))
2419 < TYPE_PRECISION (result_type))
2420 && (type = signed_or_unsigned_type (unsigned1,
2422 int_fits_type_p (arg0, type)))
2424 else if (TREE_CODE (arg1) == INTEGER_CST
2425 && (unsigned0 || !uns)
2426 && (TYPE_PRECISION (TREE_TYPE (arg0))
2427 < TYPE_PRECISION (result_type))
2428 && (type = signed_or_unsigned_type (unsigned0,
2430 int_fits_type_p (arg1, type)))
2434 /* Shifts can be shortened if shifting right. */
2439 tree arg0 = get_narrower (op0, &unsigned_arg);
2441 final_type = result_type;
2443 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2444 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2446 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2447 /* We can shorten only if the shift count is less than the
2448 number of bits in the smaller type size. */
2449 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2450 /* We cannot drop an unsigned shift after sign-extension. */
2451 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2453 /* Do an unsigned shift if the operand was zero-extended. */
2455 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
2456 /* Convert value-to-be-shifted to that type. */
2457 if (TREE_TYPE (op0) != result_type)
2458 op0 = convert (result_type, op0);
2463 /* Comparison operations are shortened too but differently.
2464 They identify themselves by setting short_compare = 1. */
2468 /* Don't write &op0, etc., because that would prevent op0
2469 from being kept in a register.
2470 Instead, make copies of the our local variables and
2471 pass the copies by reference, then copy them back afterward. */
2472 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2473 enum tree_code xresultcode = resultcode;
2475 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2480 op0 = xop0, op1 = xop1;
2482 resultcode = xresultcode;
2484 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2485 && skip_evaluation == 0)
2487 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2488 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2489 int unsignedp0, unsignedp1;
2490 tree primop0 = get_narrower (op0, &unsignedp0);
2491 tree primop1 = get_narrower (op1, &unsignedp1);
2495 STRIP_TYPE_NOPS (xop0);
2496 STRIP_TYPE_NOPS (xop1);
2498 /* Give warnings for comparisons between signed and unsigned
2499 quantities that may fail.
2501 Do the checking based on the original operand trees, so that
2502 casts will be considered, but default promotions won't be.
2504 Do not warn if the comparison is being done in a signed type,
2505 since the signed type will only be chosen if it can represent
2506 all the values of the unsigned type. */
2507 if (! TREE_UNSIGNED (result_type))
2509 /* Do not warn if both operands are the same signedness. */
2510 else if (op0_signed == op1_signed)
2517 sop = xop0, uop = xop1;
2519 sop = xop1, uop = xop0;
2521 /* Do not warn if the signed quantity is an
2522 unsuffixed integer literal (or some static
2523 constant expression involving such literals or a
2524 conditional expression involving such literals)
2525 and it is non-negative. */
2526 if (tree_expr_nonnegative_p (sop))
2528 /* Do not warn if the comparison is an equality operation,
2529 the unsigned quantity is an integral constant, and it
2530 would fit in the result if the result were signed. */
2531 else if (TREE_CODE (uop) == INTEGER_CST
2532 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2533 && int_fits_type_p (uop, signed_type (result_type)))
2535 /* Do not warn if the unsigned quantity is an enumeration
2536 constant and its maximum value would fit in the result
2537 if the result were signed. */
2538 else if (TREE_CODE (uop) == INTEGER_CST
2539 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2540 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2541 signed_type (result_type)))
2544 warning ("comparison between signed and unsigned");
2547 /* Warn if two unsigned values are being compared in a size
2548 larger than their original size, and one (and only one) is the
2549 result of a `~' operator. This comparison will always fail.
2551 Also warn if one operand is a constant, and the constant
2552 does not have all bits set that are set in the ~ operand
2553 when it is extended. */
2555 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2556 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2558 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2559 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2562 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2565 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2568 HOST_WIDE_INT constant, mask;
2569 int unsignedp, bits;
2571 if (host_integerp (primop0, 0))
2574 unsignedp = unsignedp1;
2575 constant = tree_low_cst (primop0, 0);
2580 unsignedp = unsignedp0;
2581 constant = tree_low_cst (primop1, 0);
2584 bits = TYPE_PRECISION (TREE_TYPE (primop));
2585 if (bits < TYPE_PRECISION (result_type)
2586 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2588 mask = (~ (HOST_WIDE_INT) 0) << bits;
2589 if ((mask & constant) != mask)
2590 warning ("comparison of promoted ~unsigned with constant");
2593 else if (unsignedp0 && unsignedp1
2594 && (TYPE_PRECISION (TREE_TYPE (primop0))
2595 < TYPE_PRECISION (result_type))
2596 && (TYPE_PRECISION (TREE_TYPE (primop1))
2597 < TYPE_PRECISION (result_type)))
2598 warning ("comparison of promoted ~unsigned with unsigned");
2604 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2605 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2606 Then the expression will be built.
2607 It will be given type FINAL_TYPE if that is nonzero;
2608 otherwise, it will be given type RESULT_TYPE. */
2612 binary_op_error (code);
2613 return error_mark_node;
2618 if (TREE_TYPE (op0) != result_type)
2619 op0 = convert (result_type, op0);
2620 if (TREE_TYPE (op1) != result_type)
2621 op1 = convert (result_type, op1);
2624 if (build_type == NULL_TREE)
2625 build_type = result_type;
2628 tree result = build (resultcode, build_type, op0, op1);
2631 folded = fold (result);
2632 if (folded == result)
2633 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2634 if (final_type != 0)
2635 return convert (final_type, folded);
2640 /* Return a tree for the difference of pointers OP0 and OP1.
2641 The resulting tree has type int. */
2644 pointer_diff (op0, op1)
2647 tree result, folded;
2648 tree restype = ptrdiff_type_node;
2650 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2651 tree con0, con1, lit0, lit1;
2652 tree orig_op1 = op1;
2654 if (pedantic || warn_pointer_arith)
2656 if (TREE_CODE (target_type) == VOID_TYPE)
2657 pedwarn ("pointer of type `void *' used in subtraction");
2658 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2659 pedwarn ("pointer to a function used in subtraction");
2662 /* If the conversion to ptrdiff_type does anything like widening or
2663 converting a partial to an integral mode, we get a convert_expression
2664 that is in the way to do any simplifications.
2665 (fold-const.c doesn't know that the extra bits won't be needed.
2666 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2667 different mode in place.)
2668 So first try to find a common term here 'by hand'; we want to cover
2669 at least the cases that occur in legal static initializers. */
2670 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2671 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2673 if (TREE_CODE (con0) == PLUS_EXPR)
2675 lit0 = TREE_OPERAND (con0, 1);
2676 con0 = TREE_OPERAND (con0, 0);
2679 lit0 = integer_zero_node;
2681 if (TREE_CODE (con1) == PLUS_EXPR)
2683 lit1 = TREE_OPERAND (con1, 1);
2684 con1 = TREE_OPERAND (con1, 0);
2687 lit1 = integer_zero_node;
2689 if (operand_equal_p (con0, con1, 0))
2696 /* First do the subtraction as integers;
2697 then drop through to build the divide operator.
2698 Do not do default conversions on the minus operator
2699 in case restype is a short type. */
2701 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2702 convert (restype, op1), 0);
2703 /* This generates an error if op1 is pointer to incomplete type. */
2704 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2705 error ("arithmetic on pointer to an incomplete type");
2707 /* This generates an error if op0 is pointer to incomplete type. */
2708 op1 = c_size_in_bytes (target_type);
2710 /* Divide by the size, in easiest possible way. */
2712 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2714 folded = fold (result);
2715 if (folded == result)
2716 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2720 /* Construct and perhaps optimize a tree representation
2721 for a unary operation. CODE, a tree_code, specifies the operation
2722 and XARG is the operand.
2723 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2724 the default promotions (such as from short to int).
2725 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2726 allows non-lvalues; this is only used to handle conversion of non-lvalue
2727 arrays to pointers in C99. */
2730 build_unary_op (code, xarg, flag)
2731 enum tree_code code;
2735 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2738 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2740 int noconvert = flag;
2742 if (typecode == ERROR_MARK)
2743 return error_mark_node;
2744 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2745 typecode = INTEGER_TYPE;
2750 /* This is used for unary plus, because a CONVERT_EXPR
2751 is enough to prevent anybody from looking inside for
2752 associativity, but won't generate any code. */
2753 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2754 || typecode == COMPLEX_TYPE))
2756 error ("wrong type argument to unary plus");
2757 return error_mark_node;
2759 else if (!noconvert)
2760 arg = default_conversion (arg);
2764 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2765 || typecode == COMPLEX_TYPE))
2767 error ("wrong type argument to unary minus");
2768 return error_mark_node;
2770 else if (!noconvert)
2771 arg = default_conversion (arg);
2775 if (typecode == COMPLEX_TYPE)
2779 pedwarn ("ISO C does not support `~' for complex conjugation");
2781 arg = default_conversion (arg);
2783 else if (typecode != INTEGER_TYPE)
2785 error ("wrong type argument to bit-complement");
2786 return error_mark_node;
2788 else if (!noconvert)
2789 arg = default_conversion (arg);
2793 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2794 || typecode == COMPLEX_TYPE))
2796 error ("wrong type argument to abs");
2797 return error_mark_node;
2799 else if (!noconvert)
2800 arg = default_conversion (arg);
2804 /* Conjugating a real value is a no-op, but allow it anyway. */
2805 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2806 || typecode == COMPLEX_TYPE))
2808 error ("wrong type argument to conjugation");
2809 return error_mark_node;
2811 else if (!noconvert)
2812 arg = default_conversion (arg);
2815 case TRUTH_NOT_EXPR:
2816 if (typecode != INTEGER_TYPE
2817 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2818 && typecode != COMPLEX_TYPE
2819 /* These will convert to a pointer. */
2820 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2822 error ("wrong type argument to unary exclamation mark");
2823 return error_mark_node;
2825 arg = truthvalue_conversion (arg);
2826 return invert_truthvalue (arg);
2832 if (TREE_CODE (arg) == COMPLEX_CST)
2833 return TREE_REALPART (arg);
2834 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2835 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2840 if (TREE_CODE (arg) == COMPLEX_CST)
2841 return TREE_IMAGPART (arg);
2842 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2843 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2845 return convert (TREE_TYPE (arg), integer_zero_node);
2847 case PREINCREMENT_EXPR:
2848 case POSTINCREMENT_EXPR:
2849 case PREDECREMENT_EXPR:
2850 case POSTDECREMENT_EXPR:
2851 /* Handle complex lvalues (when permitted)
2852 by reduction to simpler cases. */
2854 val = unary_complex_lvalue (code, arg, 0);
2858 /* Increment or decrement the real part of the value,
2859 and don't change the imaginary part. */
2860 if (typecode == COMPLEX_TYPE)
2865 pedwarn ("ISO C does not support `++' and `--' on complex types");
2867 arg = stabilize_reference (arg);
2868 real = build_unary_op (REALPART_EXPR, arg, 1);
2869 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2870 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2871 build_unary_op (code, real, 1), imag);
2874 /* Report invalid types. */
2876 if (typecode != POINTER_TYPE
2877 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2879 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2880 error ("wrong type argument to increment");
2882 error ("wrong type argument to decrement");
2884 return error_mark_node;
2889 tree result_type = TREE_TYPE (arg);
2891 arg = get_unwidened (arg, 0);
2892 argtype = TREE_TYPE (arg);
2894 /* Compute the increment. */
2896 if (typecode == POINTER_TYPE)
2898 /* If pointer target is an undefined struct,
2899 we just cannot know how to do the arithmetic. */
2900 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2902 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2903 error ("increment of pointer to unknown structure");
2905 error ("decrement of pointer to unknown structure");
2907 else if ((pedantic || warn_pointer_arith)
2908 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2909 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2911 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2912 pedwarn ("wrong type argument to increment");
2914 pedwarn ("wrong type argument to decrement");
2917 inc = c_size_in_bytes (TREE_TYPE (result_type));
2920 inc = integer_one_node;
2922 inc = convert (argtype, inc);
2924 /* Handle incrementing a cast-expression. */
2927 switch (TREE_CODE (arg))
2932 case FIX_TRUNC_EXPR:
2933 case FIX_FLOOR_EXPR:
2934 case FIX_ROUND_EXPR:
2936 pedantic_lvalue_warning (CONVERT_EXPR);
2937 /* If the real type has the same machine representation
2938 as the type it is cast to, we can make better output
2939 by adding directly to the inside of the cast. */
2940 if ((TREE_CODE (TREE_TYPE (arg))
2941 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2942 && (TYPE_MODE (TREE_TYPE (arg))
2943 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2944 arg = TREE_OPERAND (arg, 0);
2947 tree incremented, modify, value;
2948 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2949 value = boolean_increment (code, arg);
2952 arg = stabilize_reference (arg);
2953 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2956 value = save_expr (arg);
2957 incremented = build (((code == PREINCREMENT_EXPR
2958 || code == POSTINCREMENT_EXPR)
2959 ? PLUS_EXPR : MINUS_EXPR),
2960 argtype, value, inc);
2961 TREE_SIDE_EFFECTS (incremented) = 1;
2962 modify = build_modify_expr (arg, NOP_EXPR, incremented);
2963 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2965 TREE_USED (value) = 1;
2975 /* Complain about anything else that is not a true lvalue. */
2976 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2977 || code == POSTINCREMENT_EXPR)
2978 ? "invalid lvalue in increment"
2979 : "invalid lvalue in decrement")))
2980 return error_mark_node;
2982 /* Report a read-only lvalue. */
2983 if (TREE_READONLY (arg))
2984 readonly_warning (arg,
2985 ((code == PREINCREMENT_EXPR
2986 || code == POSTINCREMENT_EXPR)
2987 ? "increment" : "decrement"));
2989 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2990 val = boolean_increment (code, arg);
2992 val = build (code, TREE_TYPE (arg), arg, inc);
2993 TREE_SIDE_EFFECTS (val) = 1;
2994 val = convert (result_type, val);
2995 if (TREE_CODE (val) != code)
2996 TREE_NO_UNUSED_WARNING (val) = 1;
3001 /* Note that this operation never does default_conversion. */
3003 /* Let &* cancel out to simplify resulting code. */
3004 if (TREE_CODE (arg) == INDIRECT_REF)
3006 /* Don't let this be an lvalue. */
3007 if (lvalue_p (TREE_OPERAND (arg, 0)))
3008 return non_lvalue (TREE_OPERAND (arg, 0));
3009 return TREE_OPERAND (arg, 0);
3012 /* For &x[y], return x+y */
3013 if (TREE_CODE (arg) == ARRAY_REF)
3015 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3016 return error_mark_node;
3017 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3018 TREE_OPERAND (arg, 1), 1);
3021 /* Handle complex lvalues (when permitted)
3022 by reduction to simpler cases. */
3023 val = unary_complex_lvalue (code, arg, flag);
3027 #if 0 /* Turned off because inconsistent;
3028 float f; *&(int)f = 3.4 stores in int format
3029 whereas (int)f = 3.4 stores in float format. */
3030 /* Address of a cast is just a cast of the address
3031 of the operand of the cast. */
3032 switch (TREE_CODE (arg))
3037 case FIX_TRUNC_EXPR:
3038 case FIX_FLOOR_EXPR:
3039 case FIX_ROUND_EXPR:
3042 pedwarn ("ISO C forbids the address of a cast expression");
3043 return convert (build_pointer_type (TREE_TYPE (arg)),
3044 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3049 /* Anything not already handled and not a true memory reference
3050 or a non-lvalue array is an error. */
3051 else if (typecode != FUNCTION_TYPE && !flag
3052 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3053 return error_mark_node;
3055 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3056 argtype = TREE_TYPE (arg);
3058 /* If the lvalue is const or volatile, merge that into the type
3059 to which the address will point. Note that you can't get a
3060 restricted pointer by taking the address of something, so we
3061 only have to deal with `const' and `volatile' here. */
3062 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3063 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3064 argtype = c_build_type_variant (argtype,
3065 TREE_READONLY (arg),
3066 TREE_THIS_VOLATILE (arg));
3068 argtype = build_pointer_type (argtype);
3070 if (mark_addressable (arg) == 0)
3071 return error_mark_node;
3076 if (TREE_CODE (arg) == COMPONENT_REF)
3078 tree field = TREE_OPERAND (arg, 1);
3080 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
3082 if (DECL_C_BIT_FIELD (field))
3084 error ("attempt to take address of bit-field structure member `%s'",
3085 IDENTIFIER_POINTER (DECL_NAME (field)));
3086 return error_mark_node;
3089 addr = fold (build (PLUS_EXPR, argtype,
3090 convert (argtype, addr),
3091 convert (argtype, byte_position (field))));
3094 addr = build1 (code, argtype, arg);
3096 /* Address of a static or external variable or
3097 file-scope function counts as a constant. */
3099 && ! (TREE_CODE (arg) == FUNCTION_DECL
3100 && DECL_CONTEXT (arg) != 0))
3101 TREE_CONSTANT (addr) = 1;
3110 argtype = TREE_TYPE (arg);
3111 return fold (build1 (code, argtype, arg));
3115 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3116 convert ARG with the same conversions in the same order
3117 and return the result. */
3120 convert_sequence (conversions, arg)
3124 switch (TREE_CODE (conversions))
3129 case FIX_TRUNC_EXPR:
3130 case FIX_FLOOR_EXPR:
3131 case FIX_ROUND_EXPR:
3133 return convert (TREE_TYPE (conversions),
3134 convert_sequence (TREE_OPERAND (conversions, 0),
3143 /* Return nonzero if REF is an lvalue valid for this language.
3144 Lvalues can be assigned, unless their type has TYPE_READONLY.
3145 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3151 enum tree_code code = TREE_CODE (ref);
3158 return lvalue_p (TREE_OPERAND (ref, 0));
3160 case COMPOUND_LITERAL_EXPR:
3170 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3171 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3175 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3182 /* Return nonzero if REF is an lvalue valid for this language;
3183 otherwise, print an error message and return zero. */
3186 lvalue_or_else (ref, msgid)
3190 int win = lvalue_p (ref);
3193 error ("%s", msgid);
3198 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3199 for certain kinds of expressions which are not really lvalues
3200 but which we can accept as lvalues. If FLAG is nonzero, then
3201 non-lvalues are OK since we may be converting a non-lvalue array to
3204 If ARG is not a kind of expression we can handle, return zero. */
3207 unary_complex_lvalue (code, arg, flag)
3208 enum tree_code code;
3212 /* Handle (a, b) used as an "lvalue". */
3213 if (TREE_CODE (arg) == COMPOUND_EXPR)
3215 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3217 /* If this returns a function type, it isn't really being used as
3218 an lvalue, so don't issue a warning about it. */
3219 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3220 pedantic_lvalue_warning (COMPOUND_EXPR);
3222 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3223 TREE_OPERAND (arg, 0), real_result);
3226 /* Handle (a ? b : c) used as an "lvalue". */
3227 if (TREE_CODE (arg) == COND_EXPR)
3230 pedantic_lvalue_warning (COND_EXPR);
3231 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3232 pedantic_lvalue_warning (COMPOUND_EXPR);
3234 return (build_conditional_expr
3235 (TREE_OPERAND (arg, 0),
3236 build_unary_op (code, TREE_OPERAND (arg, 1), flag),
3237 build_unary_op (code, TREE_OPERAND (arg, 2), flag)));
3243 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3244 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3247 pedantic_lvalue_warning (code)
3248 enum tree_code code;
3254 pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3257 pedwarn ("ISO C forbids use of compound expressions as lvalues");
3260 pedwarn ("ISO C forbids use of cast expressions as lvalues");
3265 /* Warn about storing in something that is `const'. */
3268 readonly_warning (arg, msgid)
3272 if (TREE_CODE (arg) == COMPONENT_REF)
3274 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3275 readonly_warning (TREE_OPERAND (arg, 0), msgid);
3277 pedwarn ("%s of read-only member `%s'", _(msgid),
3278 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3280 else if (TREE_CODE (arg) == VAR_DECL)
3281 pedwarn ("%s of read-only variable `%s'", _(msgid),
3282 IDENTIFIER_POINTER (DECL_NAME (arg)));
3284 pedwarn ("%s of read-only location", _(msgid));
3287 /* Mark EXP saying that we need to be able to take the
3288 address of it; it should not be allocated in a register.
3289 Value is 1 if successful. */
3292 mark_addressable (exp)
3297 switch (TREE_CODE (x))
3300 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3302 error ("cannot take address of bit-field `%s'",
3303 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3307 /* ... fall through ... */
3313 x = TREE_OPERAND (x, 0);
3316 case COMPOUND_LITERAL_EXPR:
3318 TREE_ADDRESSABLE (x) = 1;
3325 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3326 && DECL_NONLOCAL (x))
3328 if (TREE_PUBLIC (x))
3330 error ("global register variable `%s' used in nested function",
3331 IDENTIFIER_POINTER (DECL_NAME (x)));
3334 pedwarn ("register variable `%s' used in nested function",
3335 IDENTIFIER_POINTER (DECL_NAME (x)));
3337 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3339 if (TREE_PUBLIC (x))
3341 error ("address of global register variable `%s' requested",
3342 IDENTIFIER_POINTER (DECL_NAME (x)));
3346 /* If we are making this addressable due to its having
3347 volatile components, give a different error message. Also
3348 handle the case of an unnamed parameter by not trying
3349 to give the name. */
3351 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3353 error ("cannot put object with volatile field into register");
3357 pedwarn ("address of register variable `%s' requested",
3358 IDENTIFIER_POINTER (DECL_NAME (x)));
3360 put_var_into_stack (x);
3364 TREE_ADDRESSABLE (x) = 1;
3365 #if 0 /* poplevel deals with this now. */
3366 if (DECL_CONTEXT (x) == 0)
3367 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3375 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3378 build_conditional_expr (ifexp, op1, op2)
3379 tree ifexp, op1, op2;
3383 enum tree_code code1;
3384 enum tree_code code2;
3385 tree result_type = NULL;
3386 tree orig_op1 = op1, orig_op2 = op2;
3388 ifexp = truthvalue_conversion (default_conversion (ifexp));
3390 #if 0 /* Produces wrong result if within sizeof. */
3391 /* Don't promote the operands separately if they promote
3392 the same way. Return the unpromoted type and let the combined
3393 value get promoted if necessary. */
3395 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3396 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3397 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3398 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3400 if (TREE_CODE (ifexp) == INTEGER_CST)
3401 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3403 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3407 /* Promote both alternatives. */
3409 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3410 op1 = default_conversion (op1);
3411 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3412 op2 = default_conversion (op2);
3414 if (TREE_CODE (ifexp) == ERROR_MARK
3415 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3416 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3417 return error_mark_node;
3419 type1 = TREE_TYPE (op1);
3420 code1 = TREE_CODE (type1);
3421 type2 = TREE_TYPE (op2);
3422 code2 = TREE_CODE (type2);
3424 /* Quickly detect the usual case where op1 and op2 have the same type
3426 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3429 result_type = type1;
3431 result_type = TYPE_MAIN_VARIANT (type1);
3433 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3434 || code1 == COMPLEX_TYPE)
3435 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3436 || code2 == COMPLEX_TYPE))
3438 result_type = common_type (type1, type2);
3440 /* If -Wsign-compare, warn here if type1 and type2 have
3441 different signedness. We'll promote the signed to unsigned
3442 and later code won't know it used to be different.
3443 Do this check on the original types, so that explicit casts
3444 will be considered, but default promotions won't. */
3445 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3446 && !skip_evaluation)
3448 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3449 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3451 if (unsigned_op1 ^ unsigned_op2)
3453 /* Do not warn if the result type is signed, since the
3454 signed type will only be chosen if it can represent
3455 all the values of the unsigned type. */
3456 if (! TREE_UNSIGNED (result_type))
3458 /* Do not warn if the signed quantity is an unsuffixed
3459 integer literal (or some static constant expression
3460 involving such literals) and it is non-negative. */
3461 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3462 || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3465 warning ("signed and unsigned type in conditional expression");
3469 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3471 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3472 pedwarn ("ISO C forbids conditional expr with only one void side");
3473 result_type = void_type_node;
3475 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3477 if (comp_target_types (type1, type2))
3478 result_type = common_type (type1, type2);
3479 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3480 && TREE_CODE (orig_op1) != NOP_EXPR)
3481 result_type = qualify_type (type2, type1);
3482 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3483 && TREE_CODE (orig_op2) != NOP_EXPR)
3484 result_type = qualify_type (type1, type2);
3485 else if (VOID_TYPE_P (TREE_TYPE (type1)))
3487 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3488 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3489 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3490 TREE_TYPE (type2)));
3492 else if (VOID_TYPE_P (TREE_TYPE (type2)))
3494 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3495 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3496 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3497 TREE_TYPE (type1)));
3501 pedwarn ("pointer type mismatch in conditional expression");
3502 result_type = build_pointer_type (void_type_node);
3505 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3507 if (! integer_zerop (op2))
3508 pedwarn ("pointer/integer type mismatch in conditional expression");
3511 op2 = null_pointer_node;
3513 result_type = type1;
3515 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3517 if (!integer_zerop (op1))
3518 pedwarn ("pointer/integer type mismatch in conditional expression");
3521 op1 = null_pointer_node;
3523 result_type = type2;
3528 if (flag_cond_mismatch)
3529 result_type = void_type_node;
3532 error ("type mismatch in conditional expression");
3533 return error_mark_node;
3537 /* Merge const and volatile flags of the incoming types. */
3539 = build_type_variant (result_type,
3540 TREE_READONLY (op1) || TREE_READONLY (op2),
3541 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3543 if (result_type != TREE_TYPE (op1))
3544 op1 = convert_and_check (result_type, op1);
3545 if (result_type != TREE_TYPE (op2))
3546 op2 = convert_and_check (result_type, op2);
3548 if (TREE_CODE (ifexp) == INTEGER_CST)
3549 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3551 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3554 /* Given a list of expressions, return a compound expression
3555 that performs them all and returns the value of the last of them. */
3558 build_compound_expr (list)
3561 return internal_build_compound_expr (list, TRUE);
3565 internal_build_compound_expr (list, first_p)
3571 if (TREE_CHAIN (list) == 0)
3573 /* Convert arrays and functions to pointers when there
3574 really is a comma operator. */
3577 = default_function_array_conversion (TREE_VALUE (list));
3579 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3580 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3582 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3583 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3584 list = TREE_OPERAND (list, 0);
3587 /* Don't let (0, 0) be null pointer constant. */
3588 if (!first_p && integer_zerop (TREE_VALUE (list)))
3589 return non_lvalue (TREE_VALUE (list));
3590 return TREE_VALUE (list);
3593 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3595 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3597 /* The left-hand operand of a comma expression is like an expression
3598 statement: with -W or -Wunused, we should warn if it doesn't have
3599 any side-effects, unless it was explicitly cast to (void). */
3600 if ((extra_warnings || warn_unused_value)
3601 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3602 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3603 warning ("left-hand operand of comma expression has no effect");
3605 /* When pedantic, a compound expression can be neither an lvalue
3606 nor an integer constant expression. */
3611 /* With -Wunused, we should also warn if the left-hand operand does have
3612 side-effects, but computes a value which is not used. For example, in
3613 `foo() + bar(), baz()' the result of the `+' operator is not used,
3614 so we should issue a warning. */
3615 else if (warn_unused_value)
3616 warn_if_unused_value (TREE_VALUE (list));
3618 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3621 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3624 build_c_cast (type, expr)
3630 if (type == error_mark_node || expr == error_mark_node)
3631 return error_mark_node;
3632 type = TYPE_MAIN_VARIANT (type);
3635 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3636 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3637 value = TREE_OPERAND (value, 0);
3640 if (TREE_CODE (type) == ARRAY_TYPE)
3642 error ("cast specifies array type");
3643 return error_mark_node;
3646 if (TREE_CODE (type) == FUNCTION_TYPE)
3648 error ("cast specifies function type");
3649 return error_mark_node;
3652 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3656 if (TREE_CODE (type) == RECORD_TYPE
3657 || TREE_CODE (type) == UNION_TYPE)
3658 pedwarn ("ISO C forbids casting nonscalar to the same type");
3661 else if (TREE_CODE (type) == UNION_TYPE)
3664 value = default_function_array_conversion (value);
3666 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3667 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3668 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3677 pedwarn ("ISO C forbids casts to union type");
3678 if (TYPE_NAME (type) != 0)
3680 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3681 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3683 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3687 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3688 build_tree_list (field, value)),
3690 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3693 error ("cast to union type from type not present in union");
3694 return error_mark_node;
3700 /* If casting to void, avoid the error that would come
3701 from default_conversion in the case of a non-lvalue array. */
3702 if (type == void_type_node)
3703 return build1 (CONVERT_EXPR, type, value);
3705 /* Convert functions and arrays to pointers,
3706 but don't convert any other types. */
3707 value = default_function_array_conversion (value);
3708 otype = TREE_TYPE (value);
3710 /* Optionally warn about potentially worrisome casts. */
3713 && TREE_CODE (type) == POINTER_TYPE
3714 && TREE_CODE (otype) == POINTER_TYPE)
3716 tree in_type = type;
3717 tree in_otype = otype;
3721 /* Check that the qualifiers on IN_TYPE are a superset of
3722 the qualifiers of IN_OTYPE. The outermost level of
3723 POINTER_TYPE nodes is uninteresting and we stop as soon
3724 as we hit a non-POINTER_TYPE node on either type. */
3727 in_otype = TREE_TYPE (in_otype);
3728 in_type = TREE_TYPE (in_type);
3730 /* GNU C allows cv-qualified function types. 'const'
3731 means the function is very pure, 'volatile' means it
3732 can't return. We need to warn when such qualifiers
3733 are added, not when they're taken away. */
3734 if (TREE_CODE (in_otype) == FUNCTION_TYPE
3735 && TREE_CODE (in_type) == FUNCTION_TYPE)
3736 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3738 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3740 while (TREE_CODE (in_type) == POINTER_TYPE
3741 && TREE_CODE (in_otype) == POINTER_TYPE);
3744 warning ("cast adds new qualifiers to function type");
3747 /* There are qualifiers present in IN_OTYPE that are not
3748 present in IN_TYPE. */
3749 warning ("cast discards qualifiers from pointer target type");
3752 /* Warn about possible alignment problems. */
3753 if (STRICT_ALIGNMENT && warn_cast_align
3754 && TREE_CODE (type) == POINTER_TYPE
3755 && TREE_CODE (otype) == POINTER_TYPE
3756 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3757 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3758 /* Don't warn about opaque types, where the actual alignment
3759 restriction is unknown. */
3760 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3761 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3762 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3763 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3764 warning ("cast increases required alignment of target type");
3766 if (TREE_CODE (type) == INTEGER_TYPE
3767 && TREE_CODE (otype) == POINTER_TYPE
3768 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3769 && !TREE_CONSTANT (value))
3770 warning ("cast from pointer to integer of different size");
3772 if (warn_bad_function_cast
3773 && TREE_CODE (value) == CALL_EXPR
3774 && TREE_CODE (type) != TREE_CODE (otype))
3775 warning ("cast does not match function type");
3777 if (TREE_CODE (type) == POINTER_TYPE
3778 && TREE_CODE (otype) == INTEGER_TYPE
3779 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3780 /* Don't warn about converting any constant. */
3781 && !TREE_CONSTANT (value))
3782 warning ("cast to pointer from integer of different size");
3785 value = convert (type, value);
3787 /* Ignore any integer overflow caused by the cast. */
3788 if (TREE_CODE (value) == INTEGER_CST)
3790 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3791 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3795 /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant. */
3796 if (pedantic && TREE_CODE (value) == INTEGER_CST
3797 && TREE_CODE (expr) == INTEGER_CST
3798 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3799 value = non_lvalue (value);
3801 /* If pedantic, don't let a cast be an lvalue. */
3802 if (value == expr && pedantic)
3803 value = non_lvalue (value);
3808 /* Interpret a cast of expression EXPR to type TYPE. */
3810 c_cast_expr (type, expr)
3813 int saved_wsp = warn_strict_prototypes;
3815 /* This avoids warnings about unprototyped casts on
3816 integers. E.g. "#define SIG_DFL (void(*)())0". */
3817 if (TREE_CODE (expr) == INTEGER_CST)
3818 warn_strict_prototypes = 0;
3819 type = groktypename (type);
3820 warn_strict_prototypes = saved_wsp;
3822 return build_c_cast (type, expr);
3826 /* Build an assignment expression of lvalue LHS from value RHS.
3827 MODIFYCODE is the code for a binary operator that we use
3828 to combine the old value of LHS with RHS to get the new value.
3829 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3832 build_modify_expr (lhs, modifycode, rhs)
3834 enum tree_code modifycode;
3838 tree lhstype = TREE_TYPE (lhs);
3839 tree olhstype = lhstype;
3841 /* Types that aren't fully specified cannot be used in assignments. */
3842 lhs = require_complete_type (lhs);
3844 /* Avoid duplicate error messages from operands that had errors. */
3845 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3846 return error_mark_node;
3848 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3849 /* Do not use STRIP_NOPS here. We do not want an enumerator
3850 whose value is 0 to count as a null pointer constant. */
3851 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3852 rhs = TREE_OPERAND (rhs, 0);
3856 /* Handle control structure constructs used as "lvalues". */
3858 switch (TREE_CODE (lhs))
3860 /* Handle (a, b) used as an "lvalue". */
3862 pedantic_lvalue_warning (COMPOUND_EXPR);
3863 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3864 if (TREE_CODE (newrhs) == ERROR_MARK)
3865 return error_mark_node;
3866 return build (COMPOUND_EXPR, lhstype,
3867 TREE_OPERAND (lhs, 0), newrhs);
3869 /* Handle (a ? b : c) used as an "lvalue". */
3871 pedantic_lvalue_warning (COND_EXPR);
3872 rhs = save_expr (rhs);
3874 /* Produce (a ? (b = rhs) : (c = rhs))
3875 except that the RHS goes through a save-expr
3876 so the code to compute it is only emitted once. */
3878 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3879 build_modify_expr (TREE_OPERAND (lhs, 1),
3881 build_modify_expr (TREE_OPERAND (lhs, 2),
3883 if (TREE_CODE (cond) == ERROR_MARK)
3885 /* Make sure the code to compute the rhs comes out
3886 before the split. */
3887 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3888 /* But cast it to void to avoid an "unused" error. */
3889 convert (void_type_node, rhs), cond);
3895 /* If a binary op has been requested, combine the old LHS value with the RHS
3896 producing the value we should actually store into the LHS. */
3898 if (modifycode != NOP_EXPR)
3900 lhs = stabilize_reference (lhs);
3901 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3904 /* Handle a cast used as an "lvalue".
3905 We have already performed any binary operator using the value as cast.
3906 Now convert the result to the cast type of the lhs,
3907 and then true type of the lhs and store it there;
3908 then convert result back to the cast type to be the value
3909 of the assignment. */
3911 switch (TREE_CODE (lhs))
3916 case FIX_TRUNC_EXPR:
3917 case FIX_FLOOR_EXPR:
3918 case FIX_ROUND_EXPR:
3920 newrhs = default_function_array_conversion (newrhs);
3922 tree inner_lhs = TREE_OPERAND (lhs, 0);
3924 result = build_modify_expr (inner_lhs, NOP_EXPR,
3925 convert (TREE_TYPE (inner_lhs),
3926 convert (lhstype, newrhs)));
3927 if (TREE_CODE (result) == ERROR_MARK)
3929 pedantic_lvalue_warning (CONVERT_EXPR);
3930 return convert (TREE_TYPE (lhs), result);
3937 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3938 Reject anything strange now. */
3940 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3941 return error_mark_node;
3943 /* Warn about storing in something that is `const'. */
3945 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3946 || ((TREE_CODE (lhstype) == RECORD_TYPE
3947 || TREE_CODE (lhstype) == UNION_TYPE)
3948 && C_TYPE_FIELDS_READONLY (lhstype)))
3949 readonly_warning (lhs, "assignment");
3951 /* If storing into a structure or union member,
3952 it has probably been given type `int'.
3953 Compute the type that would go with
3954 the actual amount of storage the member occupies. */
3956 if (TREE_CODE (lhs) == COMPONENT_REF
3957 && (TREE_CODE (lhstype) == INTEGER_TYPE
3958 || TREE_CODE (lhstype) == BOOLEAN_TYPE
3959 || TREE_CODE (lhstype) == REAL_TYPE
3960 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3961 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3963 /* If storing in a field that is in actuality a short or narrower than one,
3964 we must store in the field in its actual type. */
3966 if (lhstype != TREE_TYPE (lhs))
3968 lhs = copy_node (lhs);
3969 TREE_TYPE (lhs) = lhstype;
3972 /* Convert new value to destination type. */
3974 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3975 NULL_TREE, NULL_TREE, 0);
3976 if (TREE_CODE (newrhs) == ERROR_MARK)
3977 return error_mark_node;
3981 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3982 TREE_SIDE_EFFECTS (result) = 1;
3984 /* If we got the LHS in a different type for storing in,
3985 convert the result back to the nominal type of LHS
3986 so that the value we return always has the same type
3987 as the LHS argument. */
3989 if (olhstype == TREE_TYPE (result))
3991 return convert_for_assignment (olhstype, result, _("assignment"),
3992 NULL_TREE, NULL_TREE, 0);
3995 /* Convert value RHS to type TYPE as preparation for an assignment
3996 to an lvalue of type TYPE.
3997 The real work of conversion is done by `convert'.
3998 The purpose of this function is to generate error messages
3999 for assignments that are not allowed in C.
4000 ERRTYPE is a string to use in error messages:
4001 "assignment", "return", etc. If it is null, this is parameter passing
4002 for a function call (and different error messages are output).
4004 FUNNAME is the name of the function being called,
4005 as an IDENTIFIER_NODE, or null.
4006 PARMNUM is the number of the argument, for printing in error messages. */
4009 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4011 const char *errtype;
4012 tree fundecl, funname;
4015 enum tree_code codel = TREE_CODE (type);
4017 enum tree_code coder;
4019 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4020 /* Do not use STRIP_NOPS here. We do not want an enumerator
4021 whose value is 0 to count as a null pointer constant. */
4022 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4023 rhs = TREE_OPERAND (rhs, 0);
4025 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4026 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4027 rhs = default_conversion (rhs);
4028 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4029 rhs = decl_constant_value_for_broken_optimization (rhs);
4031 rhstype = TREE_TYPE (rhs);
4032 coder = TREE_CODE (rhstype);
4034 if (coder == ERROR_MARK)
4035 return error_mark_node;
4037 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4039 overflow_warning (rhs);
4040 /* Check for Objective-C protocols. This will issue a warning if
4041 there are protocol violations. No need to use the return value. */
4042 maybe_objc_comptypes (type, rhstype, 0);
4046 if (coder == VOID_TYPE)
4048 error ("void value not ignored as it ought to be");
4049 return error_mark_node;
4051 /* A type converts to a reference to it.
4052 This code doesn't fully support references, it's just for the
4053 special case of va_start and va_copy. */
4054 if (codel == REFERENCE_TYPE
4055 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4057 if (mark_addressable (rhs) == 0)
4058 return error_mark_node;
4059 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4061 /* We already know that these two types are compatible, but they
4062 may not be exactly identical. In fact, `TREE_TYPE (type)' is
4063 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4064 likely to be va_list, a typedef to __builtin_va_list, which
4065 is different enough that it will cause problems later. */
4066 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4067 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4069 rhs = build1 (NOP_EXPR, type, rhs);
4072 /* Arithmetic types all interconvert, and enum is treated like int. */
4073 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4074 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4075 || codel == BOOLEAN_TYPE)
4076 && (coder == INTEGER_TYPE || coder == REAL_TYPE
4077 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4078 || coder == BOOLEAN_TYPE))
4079 return convert_and_check (type, rhs);
4081 /* Conversion to a transparent union from its member types.
4082 This applies only to function arguments. */
4083 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4086 tree marginal_memb_type = 0;
4088 for (memb_types = TYPE_FIELDS (type); memb_types;
4089 memb_types = TREE_CHAIN (memb_types))
4091 tree memb_type = TREE_TYPE (memb_types);
4093 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4094 TYPE_MAIN_VARIANT (rhstype)))
4097 if (TREE_CODE (memb_type) != POINTER_TYPE)
4100 if (coder == POINTER_TYPE)
4102 tree ttl = TREE_TYPE (memb_type);
4103 tree ttr = TREE_TYPE (rhstype);
4105 /* Any non-function converts to a [const][volatile] void *
4106 and vice versa; otherwise, targets must be the same.
4107 Meanwhile, the lhs target must have all the qualifiers of
4109 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4110 || comp_target_types (memb_type, rhstype))
4112 /* If this type won't generate any warnings, use it. */
4113 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4114 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4115 && TREE_CODE (ttl) == FUNCTION_TYPE)
4116 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4117 == TYPE_QUALS (ttr))
4118 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4119 == TYPE_QUALS (ttl))))
4122 /* Keep looking for a better type, but remember this one. */
4123 if (! marginal_memb_type)
4124 marginal_memb_type = memb_type;
4128 /* Can convert integer zero to any pointer type. */
4129 if (integer_zerop (rhs)
4130 || (TREE_CODE (rhs) == NOP_EXPR
4131 && integer_zerop (TREE_OPERAND (rhs, 0))))
4133 rhs = null_pointer_node;
4138 if (memb_types || marginal_memb_type)
4142 /* We have only a marginally acceptable member type;
4143 it needs a warning. */
4144 tree ttl = TREE_TYPE (marginal_memb_type);
4145 tree ttr = TREE_TYPE (rhstype);
4147 /* Const and volatile mean something different for function
4148 types, so the usual warnings are not appropriate. */
4149 if (TREE_CODE (ttr) == FUNCTION_TYPE
4150 && TREE_CODE (ttl) == FUNCTION_TYPE)
4152 /* Because const and volatile on functions are
4153 restrictions that say the function will not do
4154 certain things, it is okay to use a const or volatile
4155 function where an ordinary one is wanted, but not
4157 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4158 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4159 errtype, funname, parmnum);
4161 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4162 warn_for_assignment ("%s discards qualifiers from pointer target type",
4167 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4168 pedwarn ("ISO C prohibits argument conversion to union type");
4170 return build1 (NOP_EXPR, type, rhs);
4174 /* Conversions among pointers */
4175 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4176 && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4178 tree ttl = TREE_TYPE (type);
4179 tree ttr = TREE_TYPE (rhstype);
4181 /* Any non-function converts to a [const][volatile] void *
4182 and vice versa; otherwise, targets must be the same.
4183 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4184 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4185 || comp_target_types (type, rhstype)
4186 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4187 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4190 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4193 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4194 which are not ANSI null ptr constants. */
4195 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4196 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4197 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4198 errtype, funname, parmnum);
4199 /* Const and volatile mean something different for function types,
4200 so the usual warnings are not appropriate. */
4201 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4202 && TREE_CODE (ttl) != FUNCTION_TYPE)
4204 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4205 warn_for_assignment ("%s discards qualifiers from pointer target type",
4206 errtype, funname, parmnum);
4207 /* If this is not a case of ignoring a mismatch in signedness,
4209 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4210 || comp_target_types (type, rhstype))
4212 /* If there is a mismatch, do warn. */
4214 warn_for_assignment ("pointer targets in %s differ in signedness",
4215 errtype, funname, parmnum);
4217 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4218 && TREE_CODE (ttr) == FUNCTION_TYPE)
4220 /* Because const and volatile on functions are restrictions
4221 that say the function will not do certain things,
4222 it is okay to use a const or volatile function
4223 where an ordinary one is wanted, but not vice-versa. */
4224 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4225 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4226 errtype, funname, parmnum);
4230 warn_for_assignment ("%s from incompatible pointer type",
4231 errtype, funname, parmnum);
4232 return convert (type, rhs);
4234 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4236 /* An explicit constant 0 can convert to a pointer,
4237 or one that results from arithmetic, even including
4238 a cast to integer type. */
4239 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4241 ! (TREE_CODE (rhs) == NOP_EXPR
4242 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4243 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4244 && integer_zerop (TREE_OPERAND (rhs, 0))))
4246 warn_for_assignment ("%s makes pointer from integer without a cast",
4247 errtype, funname, parmnum);
4248 return convert (type, rhs);
4250 return null_pointer_node;
4252 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4254 warn_for_assignment ("%s makes integer from pointer without a cast",
4255 errtype, funname, parmnum);
4256 return convert (type, rhs);
4258 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4259 return convert (type, rhs);
4265 tree selector = maybe_building_objc_message_expr ();
4267 if (selector && parmnum > 2)
4268 error ("incompatible type for argument %d of `%s'",
4269 parmnum - 2, IDENTIFIER_POINTER (selector));
4271 error ("incompatible type for argument %d of `%s'",
4272 parmnum, IDENTIFIER_POINTER (funname));
4275 error ("incompatible type for argument %d of indirect function call",
4279 error ("incompatible types in %s", errtype);
4281 return error_mark_node;
4284 /* Convert VALUE for assignment into inlined parameter PARM. */
4287 c_convert_parm_for_inlining (parm, value, fn)
4288 tree parm, value, fn;
4292 /* If FN was prototyped, the value has been converted already
4293 in convert_arguments. */
4294 if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
4297 type = TREE_TYPE (parm);
4298 ret = convert_for_assignment (type, value,
4299 (char *) 0 /* arg passing */, fn,
4301 if (PROMOTE_PROTOTYPES
4302 && INTEGRAL_TYPE_P (type)
4303 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
4304 ret = default_conversion (ret);
4308 /* Print a warning using MSGID.
4309 It gets OPNAME as its one parameter.
4310 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4311 FUNCTION and ARGNUM are handled specially if we are building an
4312 Objective-C selector. */
4315 warn_for_assignment (msgid, opname, function, argnum)
4323 tree selector = maybe_building_objc_message_expr ();
4326 if (selector && argnum > 2)
4328 function = selector;
4333 /* Function name is known; supply it. */
4334 const char *const argstring = _("passing arg %d of `%s'");
4335 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4336 + strlen (argstring) + 1 + 25
4338 sprintf (new_opname, argstring, argnum,
4339 IDENTIFIER_POINTER (function));
4343 /* Function name unknown (call through ptr); just give arg number. */
4344 const char *const argnofun = _("passing arg %d of pointer to function");
4345 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4346 sprintf (new_opname, argnofun, argnum);
4348 opname = new_opname;
4350 pedwarn (msgid, opname);
4353 /* If VALUE is a compound expr all of whose expressions are constant, then
4354 return its value. Otherwise, return error_mark_node.
4356 This is for handling COMPOUND_EXPRs as initializer elements
4357 which is allowed with a warning when -pedantic is specified. */
4360 valid_compound_expr_initializer (value, endtype)
4364 if (TREE_CODE (value) == COMPOUND_EXPR)
4366 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4368 return error_mark_node;
4369 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4372 else if (! TREE_CONSTANT (value)
4373 && ! initializer_constant_valid_p (value, endtype))
4374 return error_mark_node;
4379 /* Perform appropriate conversions on the initial value of a variable,
4380 store it in the declaration DECL,
4381 and print any error messages that are appropriate.
4382 If the init is invalid, store an ERROR_MARK. */
4385 store_init_value (decl, init)
4390 /* If variable's type was invalidly declared, just ignore it. */
4392 type = TREE_TYPE (decl);
4393 if (TREE_CODE (type) == ERROR_MARK)
4396 /* Digest the specified initializer into an expression. */
4398 value = digest_init (type, init, TREE_STATIC (decl),
4399 TREE_STATIC (decl) || (pedantic && !flag_isoc99));
4401 /* Store the expression if valid; else report error. */
4404 /* Note that this is the only place we can detect the error
4405 in a case such as struct foo bar = (struct foo) { x, y };
4406 where there is one initial value which is a constructor expression. */
4407 if (value == error_mark_node)
4409 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4411 error ("initializer for static variable is not constant");
4412 value = error_mark_node;
4414 else if (TREE_STATIC (decl)
4415 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4417 error ("initializer for static variable uses complicated arithmetic");
4418 value = error_mark_node;
4422 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4424 if (! TREE_CONSTANT (value))
4425 pedwarn ("aggregate initializer is not constant");
4426 else if (! TREE_STATIC (value))
4427 pedwarn ("aggregate initializer uses complicated arithmetic");
4432 if (warn_traditional && !in_system_header
4433 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4434 warning ("traditional C rejects automatic aggregate initialization");
4436 DECL_INITIAL (decl) = value;
4438 /* ANSI wants warnings about out-of-range constant initializers. */
4439 STRIP_TYPE_NOPS (value);
4440 constant_expression_warning (value);
4442 /* Check if we need to set array size from compound literal size. */
4443 if (TREE_CODE (type) == ARRAY_TYPE
4444 && TYPE_DOMAIN (type) == 0
4445 && value != error_mark_node)
4447 tree inside_init = init;
4449 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4450 inside_init = TREE_OPERAND (init, 0);
4451 inside_init = fold (inside_init);
4453 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4455 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4457 if (TYPE_DOMAIN (TREE_TYPE (decl)))
4459 /* For int foo[] = (int [3]){1}; we need to set array size
4460 now since later on array initializer will be just the
4461 brace enclosed list of the compound literal. */
4462 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
4464 layout_decl (decl, 0);
4470 /* Methods for storing and printing names for error messages. */
4472 /* Implement a spelling stack that allows components of a name to be pushed
4473 and popped. Each element on the stack is this structure. */
4485 #define SPELLING_STRING 1
4486 #define SPELLING_MEMBER 2
4487 #define SPELLING_BOUNDS 3
4489 static struct spelling *spelling; /* Next stack element (unused). */
4490 static struct spelling *spelling_base; /* Spelling stack base. */
4491 static int spelling_size; /* Size of the spelling stack. */
4493 /* Macros to save and restore the spelling stack around push_... functions.
4494 Alternative to SAVE_SPELLING_STACK. */
4496 #define SPELLING_DEPTH() (spelling - spelling_base)
4497 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4499 /* Save and restore the spelling stack around arbitrary C code. */
4501 #define SAVE_SPELLING_DEPTH(code) \
4503 int __depth = SPELLING_DEPTH (); \
4505 RESTORE_SPELLING_DEPTH (__depth); \
4508 /* Push an element on the spelling stack with type KIND and assign VALUE
4511 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4513 int depth = SPELLING_DEPTH (); \
4515 if (depth >= spelling_size) \
4517 spelling_size += 10; \
4518 if (spelling_base == 0) \
4520 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4523 = (struct spelling *) xrealloc (spelling_base, \
4524 spelling_size * sizeof (struct spelling)); \
4525 RESTORE_SPELLING_DEPTH (depth); \
4528 spelling->kind = (KIND); \
4529 spelling->MEMBER = (VALUE); \
4533 /* Push STRING on the stack. Printed literally. */
4536 push_string (string)
4539 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4542 /* Push a member name on the stack. Printed as '.' STRING. */
4545 push_member_name (decl)
4549 const char *const string
4550 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4551 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4554 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4557 push_array_bounds (bounds)
4560 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4563 /* Compute the maximum size in bytes of the printed spelling. */
4571 for (p = spelling_base; p < spelling; p++)
4573 if (p->kind == SPELLING_BOUNDS)
4576 size += strlen (p->u.s) + 1;
4582 /* Print the spelling to BUFFER and return it. */
4585 print_spelling (buffer)
4591 for (p = spelling_base; p < spelling; p++)
4592 if (p->kind == SPELLING_BOUNDS)
4594 sprintf (d, "[%d]", p->u.i);
4600 if (p->kind == SPELLING_MEMBER)
4602 for (s = p->u.s; (*d = *s++); d++)
4609 /* Issue an error message for a bad initializer component.
4610 MSGID identifies the message.
4611 The component name is taken from the spelling stack. */
4619 error ("%s", _(msgid));
4620 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4622 error ("(near initialization for `%s')", ofwhat);
4625 /* Issue a pedantic warning for a bad initializer component.
4626 MSGID identifies the message.
4627 The component name is taken from the spelling stack. */
4630 pedwarn_init (msgid)
4635 pedwarn ("%s", _(msgid));
4636 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4638 pedwarn ("(near initialization for `%s')", ofwhat);
4641 /* Issue a warning for a bad initializer component.
4642 MSGID identifies the message.
4643 The component name is taken from the spelling stack. */
4646 warning_init (msgid)
4651 warning ("%s", _(msgid));
4652 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4654 warning ("(near initialization for `%s')", ofwhat);
4657 /* Digest the parser output INIT as an initializer for type TYPE.
4658 Return a C expression of type TYPE to represent the initial value.
4660 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4661 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4662 applies only to elements of constructors. */
4665 digest_init (type, init, require_constant, constructor_constant)
4667 int require_constant, constructor_constant;
4669 enum tree_code code = TREE_CODE (type);
4670 tree inside_init = init;
4672 if (type == error_mark_node
4673 || init == error_mark_node
4674 || TREE_TYPE (init) == error_mark_node)
4675 return error_mark_node;
4677 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4678 /* Do not use STRIP_NOPS here. We do not want an enumerator
4679 whose value is 0 to count as a null pointer constant. */
4680 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4681 inside_init = TREE_OPERAND (init, 0);
4683 inside_init = fold (inside_init);
4685 /* Initialization of an array of chars from a string constant
4686 optionally enclosed in braces. */
4688 if (code == ARRAY_TYPE)
4690 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4691 if ((typ1 == char_type_node
4692 || typ1 == signed_char_type_node
4693 || typ1 == unsigned_char_type_node
4694 || typ1 == unsigned_wchar_type_node
4695 || typ1 == signed_wchar_type_node)
4696 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4698 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4699 TYPE_MAIN_VARIANT (type)))
4702 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4704 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4706 error_init ("char-array initialized from wide string");
4707 return error_mark_node;
4709 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4711 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4713 error_init ("int-array initialized from non-wide string");
4714 return error_mark_node;
4717 TREE_TYPE (inside_init) = type;
4718 if (TYPE_DOMAIN (type) != 0
4719 && TYPE_SIZE (type) != 0
4720 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4721 /* Subtract 1 (or sizeof (wchar_t))
4722 because it's ok to ignore the terminating null char
4723 that is counted in the length of the constant. */
4724 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4725 TREE_STRING_LENGTH (inside_init)
4726 - ((TYPE_PRECISION (typ1)
4727 != TYPE_PRECISION (char_type_node))
4728 ? (TYPE_PRECISION (wchar_type_node)
4731 pedwarn_init ("initializer-string for array of chars is too long");
4737 /* Any type can be initialized
4738 from an expression of the same type, optionally with braces. */
4740 if (inside_init && TREE_TYPE (inside_init) != 0
4741 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4742 TYPE_MAIN_VARIANT (type))
4743 || (code == ARRAY_TYPE
4744 && comptypes (TREE_TYPE (inside_init), type))
4745 || (code == VECTOR_TYPE
4746 && comptypes (TREE_TYPE (inside_init), type))
4747 || (code == POINTER_TYPE
4748 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4749 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4750 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4751 TREE_TYPE (type)))))
4753 if (code == POINTER_TYPE)
4754 inside_init = default_function_array_conversion (inside_init);
4756 if (require_constant && !flag_isoc99
4757 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4759 /* As an extension, allow initializing objects with static storage
4760 duration with compound literals (which are then treated just as
4761 the brace enclosed list they contain). */
4762 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4763 inside_init = DECL_INITIAL (decl);
4766 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4767 && TREE_CODE (inside_init) != CONSTRUCTOR)
4769 error_init ("array initialized from non-constant array expression");
4770 return error_mark_node;
4773 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4774 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4776 /* Compound expressions can only occur here if -pedantic or
4777 -pedantic-errors is specified. In the later case, we always want
4778 an error. In the former case, we simply want a warning. */
4779 if (require_constant && pedantic
4780 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4783 = valid_compound_expr_initializer (inside_init,
4784 TREE_TYPE (inside_init));
4785 if (inside_init == error_mark_node)
4786 error_init ("initializer element is not constant");
4788 pedwarn_init ("initializer element is not constant");
4789 if (flag_pedantic_errors)
4790 inside_init = error_mark_node;
4792 else if (require_constant
4793 && (!TREE_CONSTANT (inside_init)
4794 /* This test catches things like `7 / 0' which
4795 result in an expression for which TREE_CONSTANT
4796 is true, but which is not actually something
4797 that is a legal constant. We really should not
4798 be using this function, because it is a part of
4799 the back-end. Instead, the expression should
4800 already have been turned into ERROR_MARK_NODE. */
4801 || !initializer_constant_valid_p (inside_init,
4802 TREE_TYPE (inside_init))))
4804 error_init ("initializer element is not constant");
4805 inside_init = error_mark_node;
4811 /* Handle scalar types, including conversions. */
4813 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4814 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4816 /* Note that convert_for_assignment calls default_conversion
4817 for arrays and functions. We must not call it in the
4818 case where inside_init is a null pointer constant. */
4820 = convert_for_assignment (type, init, _("initialization"),
4821 NULL_TREE, NULL_TREE, 0);
4823 if (require_constant && ! TREE_CONSTANT (inside_init))
4825 error_init ("initializer element is not constant");
4826 inside_init = error_mark_node;
4828 else if (require_constant
4829 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4831 error_init ("initializer element is not computable at load time");
4832 inside_init = error_mark_node;
4838 /* Come here only for records and arrays. */
4840 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4842 error_init ("variable-sized object may not be initialized");
4843 return error_mark_node;
4846 /* Traditionally, you can write struct foo x = 0;
4847 and it initializes the first element of x to 0. */
4848 if (flag_traditional)
4850 tree top = 0, prev = 0, otype = type;
4851 while (TREE_CODE (type) == RECORD_TYPE
4852 || TREE_CODE (type) == ARRAY_TYPE
4853 || TREE_CODE (type) == QUAL_UNION_TYPE
4854 || TREE_CODE (type) == UNION_TYPE)
4856 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4860 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4862 if (TREE_CODE (type) == ARRAY_TYPE)
4863 type = TREE_TYPE (type);
4864 else if (TYPE_FIELDS (type))
4865 type = TREE_TYPE (TYPE_FIELDS (type));
4868 error_init ("invalid initializer");
4869 return error_mark_node;
4875 TREE_OPERAND (prev, 1)
4876 = build_tree_list (NULL_TREE,
4877 digest_init (type, init, require_constant,
4878 constructor_constant));
4882 return error_mark_node;
4884 error_init ("invalid initializer");
4885 return error_mark_node;
4888 /* Handle initializers that use braces. */
4890 /* Type of object we are accumulating a constructor for.
4891 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4892 static tree constructor_type;
4894 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4896 static tree constructor_fields;
4898 /* For an ARRAY_TYPE, this is the specified index
4899 at which to store the next element we get. */
4900 static tree constructor_index;
4902 /* For an ARRAY_TYPE, this is the maximum index. */
4903 static tree constructor_max_index;
4905 /* For a RECORD_TYPE, this is the first field not yet written out. */
4906 static tree constructor_unfilled_fields;
4908 /* For an ARRAY_TYPE, this is the index of the first element
4909 not yet written out. */
4910 static tree constructor_unfilled_index;
4912 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4913 This is so we can generate gaps between fields, when appropriate. */
4914 static tree constructor_bit_index;
4916 /* If we are saving up the elements rather than allocating them,
4917 this is the list of elements so far (in reverse order,
4918 most recent first). */
4919 static tree constructor_elements;
4921 /* 1 if constructor should be incrementally stored into a constructor chain,
4922 0 if all the elements should be kept in AVL tree. */
4923 static int constructor_incremental;
4925 /* 1 if so far this constructor's elements are all compile-time constants. */
4926 static int constructor_constant;
4928 /* 1 if so far this constructor's elements are all valid address constants. */
4929 static int constructor_simple;
4931 /* 1 if this constructor is erroneous so far. */
4932 static int constructor_erroneous;
4934 /* 1 if have called defer_addressed_constants. */
4935 static int constructor_subconstants_deferred;
4937 /* Structure for managing pending initializer elements, organized as an
4942 struct init_node *left, *right;
4943 struct init_node *parent;
4949 /* Tree of pending elements at this constructor level.
4950 These are elements encountered out of order
4951 which belong at places we haven't reached yet in actually
4953 Will never hold tree nodes across GC runs. */
4954 static struct init_node *constructor_pending_elts;
4956 /* The SPELLING_DEPTH of this constructor. */
4957 static int constructor_depth;
4959 /* 0 if implicitly pushing constructor levels is allowed. */
4960 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4962 static int require_constant_value;
4963 static int require_constant_elements;
4965 /* DECL node for which an initializer is being read.
4966 0 means we are reading a constructor expression
4967 such as (struct foo) {...}. */
4968 static tree constructor_decl;
4970 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4971 static const char *constructor_asmspec;
4973 /* Nonzero if this is an initializer for a top-level decl. */
4974 static int constructor_top_level;
4976 /* Nonzero if there were any member designators in this initializer. */
4977 static int constructor_designated;
4979 /* Nesting depth of designator list. */
4980 static int designator_depth;
4982 /* Nonzero if there were diagnosed errors in this designator list. */
4983 static int designator_errorneous;
4986 /* This stack has a level for each implicit or explicit level of
4987 structuring in the initializer, including the outermost one. It
4988 saves the values of most of the variables above. */
4990 struct constructor_range_stack;
4992 struct constructor_stack
4994 struct constructor_stack *next;
4999 tree unfilled_index;
5000 tree unfilled_fields;
5003 struct init_node *pending_elts;
5006 /* If nonzero, this value should replace the entire
5007 constructor at this level. */
5008 tree replacement_value;
5009 struct constructor_range_stack *range_stack;
5019 struct constructor_stack *constructor_stack;
5021 /* This stack represents designators from some range designator up to
5022 the last designator in the list. */
5024 struct constructor_range_stack
5026 struct constructor_range_stack *next, *prev;
5027 struct constructor_stack *stack;
5034 struct constructor_range_stack *constructor_range_stack;
5036 /* This stack records separate initializers that are nested.
5037 Nested initializers can't happen in ANSI C, but GNU C allows them
5038 in cases like { ... (struct foo) { ... } ... }. */
5040 struct initializer_stack
5042 struct initializer_stack *next;
5044 const char *asmspec;
5045 struct constructor_stack *constructor_stack;
5046 struct constructor_range_stack *constructor_range_stack;
5048 struct spelling *spelling;
5049 struct spelling *spelling_base;
5052 char require_constant_value;
5053 char require_constant_elements;
5057 struct initializer_stack *initializer_stack;
5059 /* Prepare to parse and output the initializer for variable DECL. */
5062 start_init (decl, asmspec_tree, top_level)
5068 struct initializer_stack *p
5069 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5070 const char *asmspec = 0;
5073 asmspec = TREE_STRING_POINTER (asmspec_tree);
5075 p->decl = constructor_decl;
5076 p->asmspec = constructor_asmspec;
5077 p->require_constant_value = require_constant_value;
5078 p->require_constant_elements = require_constant_elements;
5079 p->constructor_stack = constructor_stack;
5080 p->constructor_range_stack = constructor_range_stack;
5081 p->elements = constructor_elements;
5082 p->spelling = spelling;
5083 p->spelling_base = spelling_base;
5084 p->spelling_size = spelling_size;
5085 p->deferred = constructor_subconstants_deferred;
5086 p->top_level = constructor_top_level;
5087 p->next = initializer_stack;
5088 initializer_stack = p;
5090 constructor_decl = decl;
5091 constructor_asmspec = asmspec;
5092 constructor_subconstants_deferred = 0;
5093 constructor_designated = 0;
5094 constructor_top_level = top_level;
5098 require_constant_value = TREE_STATIC (decl);
5099 require_constant_elements
5100 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5101 /* For a scalar, you can always use any value to initialize,
5102 even within braces. */
5103 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5104 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5105 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5106 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5107 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5111 require_constant_value = 0;
5112 require_constant_elements = 0;
5113 locus = "(anonymous)";
5116 constructor_stack = 0;
5117 constructor_range_stack = 0;
5119 missing_braces_mentioned = 0;
5123 RESTORE_SPELLING_DEPTH (0);
5126 push_string (locus);
5132 struct initializer_stack *p = initializer_stack;
5134 /* Output subconstants (string constants, usually)
5135 that were referenced within this initializer and saved up.
5136 Must do this if and only if we called defer_addressed_constants. */
5137 if (constructor_subconstants_deferred)
5138 output_deferred_addressed_constants ();
5140 /* Free the whole constructor stack of this initializer. */
5141 while (constructor_stack)
5143 struct constructor_stack *q = constructor_stack;
5144 constructor_stack = q->next;
5148 if (constructor_range_stack)
5151 /* Pop back to the data of the outer initializer (if any). */
5152 constructor_decl = p->decl;
5153 constructor_asmspec = p->asmspec;
5154 require_constant_value = p->require_constant_value;
5155 require_constant_elements = p->require_constant_elements;
5156 constructor_stack = p->constructor_stack;
5157 constructor_range_stack = p->constructor_range_stack;
5158 constructor_elements = p->elements;
5159 spelling = p->spelling;
5160 spelling_base = p->spelling_base;
5161 spelling_size = p->spelling_size;
5162 constructor_subconstants_deferred = p->deferred;
5163 constructor_top_level = p->top_level;
5164 initializer_stack = p->next;
5168 /* Call here when we see the initializer is surrounded by braces.
5169 This is instead of a call to push_init_level;
5170 it is matched by a call to pop_init_level.
5172 TYPE is the type to initialize, for a constructor expression.
5173 For an initializer for a decl, TYPE is zero. */
5176 really_start_incremental_init (type)
5179 struct constructor_stack *p
5180 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5183 type = TREE_TYPE (constructor_decl);
5185 p->type = constructor_type;
5186 p->fields = constructor_fields;
5187 p->index = constructor_index;
5188 p->max_index = constructor_max_index;
5189 p->unfilled_index = constructor_unfilled_index;
5190 p->unfilled_fields = constructor_unfilled_fields;
5191 p->bit_index = constructor_bit_index;
5192 p->elements = constructor_elements;
5193 p->constant = constructor_constant;
5194 p->simple = constructor_simple;
5195 p->erroneous = constructor_erroneous;
5196 p->pending_elts = constructor_pending_elts;
5197 p->depth = constructor_depth;
5198 p->replacement_value = 0;
5202 p->incremental = constructor_incremental;
5203 p->designated = constructor_designated;
5205 constructor_stack = p;
5207 constructor_constant = 1;
5208 constructor_simple = 1;
5209 constructor_depth = SPELLING_DEPTH ();
5210 constructor_elements = 0;
5211 constructor_pending_elts = 0;
5212 constructor_type = type;
5213 constructor_incremental = 1;
5214 constructor_designated = 0;
5215 designator_depth = 0;
5216 designator_errorneous = 0;
5218 if (TREE_CODE (constructor_type) == RECORD_TYPE
5219 || TREE_CODE (constructor_type) == UNION_TYPE)
5221 constructor_fields = TYPE_FIELDS (constructor_type);
5222 /* Skip any nameless bit fields at the beginning. */
5223 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5224 && DECL_NAME (constructor_fields) == 0)
5225 constructor_fields = TREE_CHAIN (constructor_fields);
5227 constructor_unfilled_fields = constructor_fields;
5228 constructor_bit_index = bitsize_zero_node;
5230 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5232 if (TYPE_DOMAIN (constructor_type))
5234 constructor_max_index
5235 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5237 /* Detect non-empty initializations of zero-length arrays. */
5238 if (constructor_max_index == NULL_TREE
5239 && TYPE_SIZE (constructor_type))
5240 constructor_max_index = build_int_2 (-1, -1);
5242 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5243 to initialize VLAs will cause an proper error; avoid tree
5244 checking errors as well by setting a safe value. */
5245 if (constructor_max_index
5246 && TREE_CODE (constructor_max_index) != INTEGER_CST)
5247 constructor_max_index = build_int_2 (-1, -1);
5250 = convert (bitsizetype,
5251 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5254 constructor_index = bitsize_zero_node;
5256 constructor_unfilled_index = constructor_index;
5258 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5260 /* Vectors are like simple fixed-size arrays. */
5261 constructor_max_index =
5262 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
5263 constructor_index = convert (bitsizetype, integer_zero_node);
5264 constructor_unfilled_index = constructor_index;
5268 /* Handle the case of int x = {5}; */
5269 constructor_fields = constructor_type;
5270 constructor_unfilled_fields = constructor_type;
5274 /* Push down into a subobject, for initialization.
5275 If this is for an explicit set of braces, IMPLICIT is 0.
5276 If it is because the next element belongs at a lower level,
5277 IMPLICIT is 1 (or 2 if the push is because of designator list). */
5280 push_init_level (implicit)
5283 struct constructor_stack *p;
5284 tree value = NULL_TREE;
5286 /* If we've exhausted any levels that didn't have braces,
5288 while (constructor_stack->implicit)
5290 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5291 || TREE_CODE (constructor_type) == UNION_TYPE)
5292 && constructor_fields == 0)
5293 process_init_element (pop_init_level (1));
5294 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5295 && tree_int_cst_lt (constructor_max_index, constructor_index))
5296 process_init_element (pop_init_level (1));
5301 /* Unless this is an explicit brace, we need to preserve previous
5305 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5306 || TREE_CODE (constructor_type) == UNION_TYPE)
5307 && constructor_fields)
5308 value = find_init_member (constructor_fields);
5309 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5310 value = find_init_member (constructor_index);
5313 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5314 p->type = constructor_type;
5315 p->fields = constructor_fields;
5316 p->index = constructor_index;
5317 p->max_index = constructor_max_index;
5318 p->unfilled_index = constructor_unfilled_index;
5319 p->unfilled_fields = constructor_unfilled_fields;
5320 p->bit_index = constructor_bit_index;
5321 p->elements = constructor_elements;
5322 p->constant = constructor_constant;
5323 p->simple = constructor_simple;
5324 p->erroneous = constructor_erroneous;
5325 p->pending_elts = constructor_pending_elts;
5326 p->depth = constructor_depth;
5327 p->replacement_value = 0;
5328 p->implicit = implicit;
5330 p->incremental = constructor_incremental;
5331 p->designated = constructor_designated;
5332 p->next = constructor_stack;
5334 constructor_stack = p;
5336 constructor_constant = 1;
5337 constructor_simple = 1;
5338 constructor_depth = SPELLING_DEPTH ();
5339 constructor_elements = 0;
5340 constructor_incremental = 1;
5341 constructor_designated = 0;
5342 constructor_pending_elts = 0;
5345 p->range_stack = constructor_range_stack;
5346 constructor_range_stack = 0;
5347 designator_depth = 0;
5348 designator_errorneous = 0;
5351 /* Don't die if an entire brace-pair level is superfluous
5352 in the containing level. */
5353 if (constructor_type == 0)
5355 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5356 || TREE_CODE (constructor_type) == UNION_TYPE)
5358 /* Don't die if there are extra init elts at the end. */
5359 if (constructor_fields == 0)
5360 constructor_type = 0;
5363 constructor_type = TREE_TYPE (constructor_fields);
5364 push_member_name (constructor_fields);
5365 constructor_depth++;
5368 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5370 constructor_type = TREE_TYPE (constructor_type);
5371 push_array_bounds (tree_low_cst (constructor_index, 0));
5372 constructor_depth++;
5375 if (constructor_type == 0)
5377 error_init ("extra brace group at end of initializer");
5378 constructor_fields = 0;
5379 constructor_unfilled_fields = 0;
5383 if (value && TREE_CODE (value) == CONSTRUCTOR)
5385 constructor_constant = TREE_CONSTANT (value);
5386 constructor_simple = TREE_STATIC (value);
5387 constructor_elements = TREE_OPERAND (value, 1);
5388 if (constructor_elements
5389 && (TREE_CODE (constructor_type) == RECORD_TYPE
5390 || TREE_CODE (constructor_type) == ARRAY_TYPE))
5391 set_nonincremental_init ();
5394 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5396 missing_braces_mentioned = 1;
5397 warning_init ("missing braces around initializer");
5400 if (TREE_CODE (constructor_type) == RECORD_TYPE
5401 || TREE_CODE (constructor_type) == UNION_TYPE)
5403 constructor_fields = TYPE_FIELDS (constructor_type);
5404 /* Skip any nameless bit fields at the beginning. */
5405 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5406 && DECL_NAME (constructor_fields) == 0)
5407 constructor_fields = TREE_CHAIN (constructor_fields);
5409 constructor_unfilled_fields = constructor_fields;
5410 constructor_bit_index = bitsize_zero_node;
5412 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5414 /* Vectors are like simple fixed-size arrays. */
5415 constructor_max_index =
5416 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
5417 constructor_index = convert (bitsizetype, integer_zero_node);
5418 constructor_unfilled_index = constructor_index;
5420 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5422 if (TYPE_DOMAIN (constructor_type))
5424 constructor_max_index
5425 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5427 /* Detect non-empty initializations of zero-length arrays. */
5428 if (constructor_max_index == NULL_TREE
5429 && TYPE_SIZE (constructor_type))
5430 constructor_max_index = build_int_2 (-1, -1);
5432 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5433 to initialize VLAs will cause an proper error; avoid tree
5434 checking errors as well by setting a safe value. */
5435 if (constructor_max_index
5436 && TREE_CODE (constructor_max_index) != INTEGER_CST)
5437 constructor_max_index = build_int_2 (-1, -1);
5440 = convert (bitsizetype,
5441 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5444 constructor_index = bitsize_zero_node;
5446 constructor_unfilled_index = constructor_index;
5447 if (value && TREE_CODE (value) == STRING_CST)
5449 /* We need to split the char/wchar array into individual
5450 characters, so that we don't have to special case it
5452 set_nonincremental_init_from_string (value);
5457 warning_init ("braces around scalar initializer");
5458 constructor_fields = constructor_type;
5459 constructor_unfilled_fields = constructor_type;
5463 /* At the end of an implicit or explicit brace level,
5464 finish up that level of constructor.
5465 If we were outputting the elements as they are read, return 0
5466 from inner levels (process_init_element ignores that),
5467 but return error_mark_node from the outermost level
5468 (that's what we want to put in DECL_INITIAL).
5469 Otherwise, return a CONSTRUCTOR expression. */
5472 pop_init_level (implicit)
5475 struct constructor_stack *p;
5476 tree constructor = 0;
5480 /* When we come to an explicit close brace,
5481 pop any inner levels that didn't have explicit braces. */
5482 while (constructor_stack->implicit)
5483 process_init_element (pop_init_level (1));
5485 if (constructor_range_stack)
5489 p = constructor_stack;
5491 /* Error for initializing a flexible array member, or a zero-length
5492 array member in an inappropriate context. */
5493 if (constructor_type && constructor_fields
5494 && TREE_CODE (constructor_type) == ARRAY_TYPE
5495 && TYPE_DOMAIN (constructor_type)
5496 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5498 /* Silently discard empty initializations. The parser will
5499 already have pedwarned for empty brackets. */
5500 if (integer_zerop (constructor_unfilled_index))
5501 constructor_type = NULL_TREE;
5502 else if (! TYPE_SIZE (constructor_type))
5504 if (constructor_depth > 2)
5505 error_init ("initialization of flexible array member in a nested context");
5507 pedwarn_init ("initialization of a flexible array member");
5509 /* We have already issued an error message for the existence
5510 of a flexible array member not at the end of the structure.
5511 Discard the initializer so that we do not abort later. */
5512 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5513 constructor_type = NULL_TREE;
5516 /* Zero-length arrays are no longer special, so we should no longer
5521 /* Warn when some struct elements are implicitly initialized to zero. */
5524 && TREE_CODE (constructor_type) == RECORD_TYPE
5525 && constructor_unfilled_fields)
5527 /* Do not warn for flexible array members or zero-length arrays. */
5528 while (constructor_unfilled_fields
5529 && (! DECL_SIZE (constructor_unfilled_fields)
5530 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5531 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5533 /* Do not warn if this level of the initializer uses member
5534 designators; it is likely to be deliberate. */
5535 if (constructor_unfilled_fields && !constructor_designated)
5537 push_member_name (constructor_unfilled_fields);
5538 warning_init ("missing initializer");
5539 RESTORE_SPELLING_DEPTH (constructor_depth);
5543 /* Now output all pending elements. */
5544 constructor_incremental = 1;
5545 output_pending_init_elements (1);
5547 /* Pad out the end of the structure. */
5548 if (p->replacement_value)
5549 /* If this closes a superfluous brace pair,
5550 just pass out the element between them. */
5551 constructor = p->replacement_value;
5552 else if (constructor_type == 0)
5554 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5555 && TREE_CODE (constructor_type) != UNION_TYPE
5556 && TREE_CODE (constructor_type) != ARRAY_TYPE
5557 && TREE_CODE (constructor_type) != VECTOR_TYPE)
5559 /* A nonincremental scalar initializer--just return
5560 the element, after verifying there is just one. */
5561 if (constructor_elements == 0)
5563 if (!constructor_erroneous)
5564 error_init ("empty scalar initializer");
5565 constructor = error_mark_node;
5567 else if (TREE_CHAIN (constructor_elements) != 0)
5569 error_init ("extra elements in scalar initializer");
5570 constructor = TREE_VALUE (constructor_elements);
5573 constructor = TREE_VALUE (constructor_elements);
5577 if (constructor_erroneous)
5578 constructor = error_mark_node;
5581 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5582 nreverse (constructor_elements));
5583 if (constructor_constant)
5584 TREE_CONSTANT (constructor) = 1;
5585 if (constructor_constant && constructor_simple)
5586 TREE_STATIC (constructor) = 1;
5590 constructor_type = p->type;
5591 constructor_fields = p->fields;
5592 constructor_index = p->index;
5593 constructor_max_index = p->max_index;
5594 constructor_unfilled_index = p->unfilled_index;
5595 constructor_unfilled_fields = p->unfilled_fields;
5596 constructor_bit_index = p->bit_index;
5597 constructor_elements = p->elements;
5598 constructor_constant = p->constant;
5599 constructor_simple = p->simple;
5600 constructor_erroneous = p->erroneous;
5601 constructor_incremental = p->incremental;
5602 constructor_designated = p->designated;
5603 constructor_pending_elts = p->pending_elts;
5604 constructor_depth = p->depth;
5606 constructor_range_stack = p->range_stack;
5607 RESTORE_SPELLING_DEPTH (constructor_depth);
5609 constructor_stack = p->next;
5612 if (constructor == 0)
5614 if (constructor_stack == 0)
5615 return error_mark_node;
5621 /* Common handling for both array range and field name designators.
5622 ARRAY argument is non-zero for array ranges. Returns zero for success. */
5625 set_designator (array)
5629 enum tree_code subcode;
5631 /* Don't die if an entire brace-pair level is superfluous
5632 in the containing level. */
5633 if (constructor_type == 0)
5636 /* If there were errors in this designator list already, bail out silently. */
5637 if (designator_errorneous)
5640 if (!designator_depth)
5642 if (constructor_range_stack)
5645 /* Designator list starts at the level of closest explicit
5647 while (constructor_stack->implicit)
5648 process_init_element (pop_init_level (1));
5649 constructor_designated = 1;
5653 if (constructor_no_implicit)
5655 error_init ("initialization designators may not nest");
5659 if (TREE_CODE (constructor_type) == RECORD_TYPE
5660 || TREE_CODE (constructor_type) == UNION_TYPE)
5662 subtype = TREE_TYPE (constructor_fields);
5663 if (subtype != error_mark_node)
5664 subtype = TYPE_MAIN_VARIANT (subtype);
5666 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5668 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5673 subcode = TREE_CODE (subtype);
5674 if (array && subcode != ARRAY_TYPE)
5676 error_init ("array index in non-array initializer");
5679 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5681 error_init ("field name not in record or union initializer");
5685 constructor_designated = 1;
5686 push_init_level (2);
5690 /* If there are range designators in designator list, push a new designator
5691 to constructor_range_stack. RANGE_END is end of such stack range or
5692 NULL_TREE if there is no range designator at this level. */
5695 push_range_stack (range_end)
5698 struct constructor_range_stack *p;
5700 p = (struct constructor_range_stack *)
5701 ggc_alloc (sizeof (struct constructor_range_stack));
5702 p->prev = constructor_range_stack;
5704 p->fields = constructor_fields;
5705 p->range_start = constructor_index;
5706 p->index = constructor_index;
5707 p->stack = constructor_stack;
5708 p->range_end = range_end;
5709 if (constructor_range_stack)
5710 constructor_range_stack->next = p;
5711 constructor_range_stack = p;
5714 /* Within an array initializer, specify the next index to be initialized.
5715 FIRST is that index. If LAST is nonzero, then initialize a range
5716 of indices, running from FIRST through LAST. */
5719 set_init_index (first, last)
5722 if (set_designator (1))
5725 designator_errorneous = 1;
5727 while ((TREE_CODE (first) == NOP_EXPR
5728 || TREE_CODE (first) == CONVERT_EXPR
5729 || TREE_CODE (first) == NON_LVALUE_EXPR)
5730 && (TYPE_MODE (TREE_TYPE (first))
5731 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5732 first = TREE_OPERAND (first, 0);
5735 while ((TREE_CODE (last) == NOP_EXPR
5736 || TREE_CODE (last) == CONVERT_EXPR
5737 || TREE_CODE (last) == NON_LVALUE_EXPR)
5738 && (TYPE_MODE (TREE_TYPE (last))
5739 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5740 last = TREE_OPERAND (last, 0);
5742 if (TREE_CODE (first) != INTEGER_CST)
5743 error_init ("nonconstant array index in initializer");
5744 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5745 error_init ("nonconstant array index in initializer");
5746 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5747 error_init ("array index in non-array initializer");
5748 else if (constructor_max_index
5749 && tree_int_cst_lt (constructor_max_index, first))
5750 error_init ("array index in initializer exceeds array bounds");
5753 constructor_index = convert (bitsizetype, first);
5757 if (tree_int_cst_equal (first, last))
5759 else if (tree_int_cst_lt (last, first))
5761 error_init ("empty index range in initializer");
5766 last = convert (bitsizetype, last);
5767 if (constructor_max_index != 0
5768 && tree_int_cst_lt (constructor_max_index, last))
5770 error_init ("array index range in initializer exceeds array bounds");
5777 designator_errorneous = 0;
5778 if (constructor_range_stack || last)
5779 push_range_stack (last);
5783 /* Within a struct initializer, specify the next field to be initialized. */
5786 set_init_label (fieldname)
5791 if (set_designator (0))
5794 designator_errorneous = 1;
5796 if (TREE_CODE (constructor_type) != RECORD_TYPE
5797 && TREE_CODE (constructor_type) != UNION_TYPE)
5799 error_init ("field name not in record or union initializer");
5803 for (tail = TYPE_FIELDS (constructor_type); tail;
5804 tail = TREE_CHAIN (tail))
5806 if (DECL_NAME (tail) == fieldname)
5811 error ("unknown field `%s' specified in initializer",
5812 IDENTIFIER_POINTER (fieldname));
5815 constructor_fields = tail;
5817 designator_errorneous = 0;
5818 if (constructor_range_stack)
5819 push_range_stack (NULL_TREE);
5823 /* Add a new initializer to the tree of pending initializers. PURPOSE
5824 identifies the initializer, either array index or field in a structure.
5825 VALUE is the value of that index or field. */
5828 add_pending_init (purpose, value)
5829 tree purpose, value;
5831 struct init_node *p, **q, *r;
5833 q = &constructor_pending_elts;
5836 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5841 if (tree_int_cst_lt (purpose, p->purpose))
5843 else if (tree_int_cst_lt (p->purpose, purpose))
5847 if (TREE_SIDE_EFFECTS (p->value))
5848 warning_init ("initialized field with side-effects overwritten");
5858 bitpos = bit_position (purpose);
5862 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5864 else if (p->purpose != purpose)
5868 if (TREE_SIDE_EFFECTS (p->value))
5869 warning_init ("initialized field with side-effects overwritten");
5876 r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5877 r->purpose = purpose;
5888 struct init_node *s;
5892 if (p->balance == 0)
5894 else if (p->balance < 0)
5901 p->left->parent = p;
5918 constructor_pending_elts = r;
5923 struct init_node *t = r->right;
5927 r->right->parent = r;
5932 p->left->parent = p;
5935 p->balance = t->balance < 0;
5936 r->balance = -(t->balance > 0);
5951 constructor_pending_elts = t;
5957 /* p->balance == +1; growth of left side balances the node. */
5962 else /* r == p->right */
5964 if (p->balance == 0)
5965 /* Growth propagation from right side. */
5967 else if (p->balance > 0)
5974 p->right->parent = p;
5991 constructor_pending_elts = r;
5993 else /* r->balance == -1 */
5996 struct init_node *t = r->left;
6000 r->left->parent = r;
6005 p->right->parent = p;
6008 r->balance = (t->balance < 0);
6009 p->balance = -(t->balance > 0);
6024 constructor_pending_elts = t;
6030 /* p->balance == -1; growth of right side balances the node. */
6041 /* Build AVL tree from a sorted chain. */
6044 set_nonincremental_init ()
6048 if (TREE_CODE (constructor_type) != RECORD_TYPE
6049 && TREE_CODE (constructor_type) != ARRAY_TYPE)
6052 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
6053 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
6054 constructor_elements = 0;
6055 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6057 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6058 /* Skip any nameless bit fields at the beginning. */
6059 while (constructor_unfilled_fields != 0
6060 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6061 && DECL_NAME (constructor_unfilled_fields) == 0)
6062 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6065 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6067 if (TYPE_DOMAIN (constructor_type))
6068 constructor_unfilled_index
6069 = convert (bitsizetype,
6070 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6072 constructor_unfilled_index = bitsize_zero_node;
6074 constructor_incremental = 0;
6077 /* Build AVL tree from a string constant. */
6080 set_nonincremental_init_from_string (str)
6083 tree value, purpose, type;
6084 HOST_WIDE_INT val[2];
6085 const char *p, *end;
6086 int byte, wchar_bytes, charwidth, bitpos;
6088 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6091 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6092 == TYPE_PRECISION (char_type_node))
6094 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6095 == TYPE_PRECISION (wchar_type_node))
6096 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6100 charwidth = TYPE_PRECISION (char_type_node);
6101 type = TREE_TYPE (constructor_type);
6102 p = TREE_STRING_POINTER (str);
6103 end = p + TREE_STRING_LENGTH (str);
6105 for (purpose = bitsize_zero_node;
6106 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6107 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6109 if (wchar_bytes == 1)
6111 val[1] = (unsigned char) *p++;
6118 for (byte = 0; byte < wchar_bytes; byte++)
6120 if (BYTES_BIG_ENDIAN)
6121 bitpos = (wchar_bytes - byte - 1) * charwidth;
6123 bitpos = byte * charwidth;
6124 val[bitpos < HOST_BITS_PER_WIDE_INT]
6125 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6126 << (bitpos % HOST_BITS_PER_WIDE_INT);
6130 if (!TREE_UNSIGNED (type))
6132 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6133 if (bitpos < HOST_BITS_PER_WIDE_INT)
6135 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6137 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6141 else if (bitpos == HOST_BITS_PER_WIDE_INT)
6146 else if (val[0] & (((HOST_WIDE_INT) 1)
6147 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6148 val[0] |= ((HOST_WIDE_INT) -1)
6149 << (bitpos - HOST_BITS_PER_WIDE_INT);
6152 value = build_int_2 (val[1], val[0]);
6153 TREE_TYPE (value) = type;
6154 add_pending_init (purpose, value);
6157 constructor_incremental = 0;
6160 /* Return value of FIELD in pending initializer or zero if the field was
6161 not initialized yet. */
6164 find_init_member (field)
6167 struct init_node *p;
6169 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6171 if (constructor_incremental
6172 && tree_int_cst_lt (field, constructor_unfilled_index))
6173 set_nonincremental_init ();
6175 p = constructor_pending_elts;
6178 if (tree_int_cst_lt (field, p->purpose))
6180 else if (tree_int_cst_lt (p->purpose, field))
6186 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6188 tree bitpos = bit_position (field);
6190 if (constructor_incremental
6191 && (!constructor_unfilled_fields
6192 || tree_int_cst_lt (bitpos,
6193 bit_position (constructor_unfilled_fields))))
6194 set_nonincremental_init ();
6196 p = constructor_pending_elts;
6199 if (field == p->purpose)
6201 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6207 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6209 if (constructor_elements
6210 && TREE_PURPOSE (constructor_elements) == field)
6211 return TREE_VALUE (constructor_elements);
6216 /* "Output" the next constructor element.
6217 At top level, really output it to assembler code now.
6218 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6219 TYPE is the data type that the containing data type wants here.
6220 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6222 PENDING if non-nil means output pending elements that belong
6223 right after this element. (PENDING is normally 1;
6224 it is 0 while outputting pending elements, to avoid recursion.) */
6227 output_init_element (value, type, field, pending)
6228 tree value, type, field;
6231 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6232 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6233 && !(TREE_CODE (value) == STRING_CST
6234 && TREE_CODE (type) == ARRAY_TYPE
6235 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6236 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6237 TYPE_MAIN_VARIANT (type))))
6238 value = default_conversion (value);
6240 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
6241 && require_constant_value && !flag_isoc99 && pending)
6243 /* As an extension, allow initializing objects with static storage
6244 duration with compound literals (which are then treated just as
6245 the brace enclosed list they contain). */
6246 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
6247 value = DECL_INITIAL (decl);
6250 if (value == error_mark_node)
6251 constructor_erroneous = 1;
6252 else if (!TREE_CONSTANT (value))
6253 constructor_constant = 0;
6254 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6255 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6256 || TREE_CODE (constructor_type) == UNION_TYPE)
6257 && DECL_C_BIT_FIELD (field)
6258 && TREE_CODE (value) != INTEGER_CST))
6259 constructor_simple = 0;
6261 if (require_constant_value && ! TREE_CONSTANT (value))
6263 error_init ("initializer element is not constant");
6264 value = error_mark_node;
6266 else if (require_constant_elements
6267 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6268 pedwarn ("initializer element is not computable at load time");
6270 /* If this field is empty (and not at the end of structure),
6271 don't do anything other than checking the initializer. */
6273 && (TREE_TYPE (field) == error_mark_node
6274 || (COMPLETE_TYPE_P (TREE_TYPE (field))
6275 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6276 && (TREE_CODE (constructor_type) == ARRAY_TYPE
6277 || TREE_CHAIN (field)))))
6280 value = digest_init (type, value, require_constant_value,
6281 require_constant_elements);
6282 if (value == error_mark_node)
6284 constructor_erroneous = 1;
6288 /* If this element doesn't come next in sequence,
6289 put it on constructor_pending_elts. */
6290 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6291 && (!constructor_incremental
6292 || !tree_int_cst_equal (field, constructor_unfilled_index)))
6294 if (constructor_incremental
6295 && tree_int_cst_lt (field, constructor_unfilled_index))
6296 set_nonincremental_init ();
6298 add_pending_init (field, value);
6301 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6302 && (!constructor_incremental
6303 || field != constructor_unfilled_fields))
6305 /* We do this for records but not for unions. In a union,
6306 no matter which field is specified, it can be initialized
6307 right away since it starts at the beginning of the union. */
6308 if (constructor_incremental)
6310 if (!constructor_unfilled_fields)
6311 set_nonincremental_init ();
6314 tree bitpos, unfillpos;
6316 bitpos = bit_position (field);
6317 unfillpos = bit_position (constructor_unfilled_fields);
6319 if (tree_int_cst_lt (bitpos, unfillpos))
6320 set_nonincremental_init ();
6324 add_pending_init (field, value);
6327 else if (TREE_CODE (constructor_type) == UNION_TYPE
6328 && constructor_elements)
6330 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6331 warning_init ("initialized field with side-effects overwritten");
6333 /* We can have just one union field set. */
6334 constructor_elements = 0;
6337 /* Otherwise, output this element either to
6338 constructor_elements or to the assembler file. */
6340 if (field && TREE_CODE (field) == INTEGER_CST)
6341 field = copy_node (field);
6342 constructor_elements
6343 = tree_cons (field, value, constructor_elements);
6345 /* Advance the variable that indicates sequential elements output. */
6346 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6347 constructor_unfilled_index
6348 = size_binop (PLUS_EXPR, constructor_unfilled_index,
6350 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6352 constructor_unfilled_fields
6353 = TREE_CHAIN (constructor_unfilled_fields);
6355 /* Skip any nameless bit fields. */
6356 while (constructor_unfilled_fields != 0
6357 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6358 && DECL_NAME (constructor_unfilled_fields) == 0)
6359 constructor_unfilled_fields =
6360 TREE_CHAIN (constructor_unfilled_fields);
6362 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6363 constructor_unfilled_fields = 0;
6365 /* Now output any pending elements which have become next. */
6367 output_pending_init_elements (0);
6370 /* Output any pending elements which have become next.
6371 As we output elements, constructor_unfilled_{fields,index}
6372 advances, which may cause other elements to become next;
6373 if so, they too are output.
6375 If ALL is 0, we return when there are
6376 no more pending elements to output now.
6378 If ALL is 1, we output space as necessary so that
6379 we can output all the pending elements. */
6382 output_pending_init_elements (all)
6385 struct init_node *elt = constructor_pending_elts;
6390 /* Look thru the whole pending tree.
6391 If we find an element that should be output now,
6392 output it. Otherwise, set NEXT to the element
6393 that comes first among those still pending. */
6398 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6400 if (tree_int_cst_equal (elt->purpose,
6401 constructor_unfilled_index))
6402 output_init_element (elt->value,
6403 TREE_TYPE (constructor_type),
6404 constructor_unfilled_index, 0);
6405 else if (tree_int_cst_lt (constructor_unfilled_index,
6408 /* Advance to the next smaller node. */
6413 /* We have reached the smallest node bigger than the
6414 current unfilled index. Fill the space first. */
6415 next = elt->purpose;
6421 /* Advance to the next bigger node. */
6426 /* We have reached the biggest node in a subtree. Find
6427 the parent of it, which is the next bigger node. */
6428 while (elt->parent && elt->parent->right == elt)
6431 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6434 next = elt->purpose;
6440 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6441 || TREE_CODE (constructor_type) == UNION_TYPE)
6443 tree ctor_unfilled_bitpos, elt_bitpos;
6445 /* If the current record is complete we are done. */
6446 if (constructor_unfilled_fields == 0)
6449 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6450 elt_bitpos = bit_position (elt->purpose);
6451 /* We can't compare fields here because there might be empty
6452 fields in between. */
6453 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6455 constructor_unfilled_fields = elt->purpose;
6456 output_init_element (elt->value, TREE_TYPE (elt->purpose),
6459 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6461 /* Advance to the next smaller node. */
6466 /* We have reached the smallest node bigger than the
6467 current unfilled field. Fill the space first. */
6468 next = elt->purpose;
6474 /* Advance to the next bigger node. */
6479 /* We have reached the biggest node in a subtree. Find
6480 the parent of it, which is the next bigger node. */
6481 while (elt->parent && elt->parent->right == elt)
6485 && (tree_int_cst_lt (ctor_unfilled_bitpos,
6486 bit_position (elt->purpose))))
6488 next = elt->purpose;
6496 /* Ordinarily return, but not if we want to output all
6497 and there are elements left. */
6498 if (! (all && next != 0))
6501 /* If it's not incremental, just skip over the gap, so that after
6502 jumping to retry we will output the next successive element. */
6503 if (TREE_CODE (constructor_type) == RECORD_TYPE
6504 || TREE_CODE (constructor_type) == UNION_TYPE)
6505 constructor_unfilled_fields = next;
6506 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6507 constructor_unfilled_index = next;
6509 /* ELT now points to the node in the pending tree with the next
6510 initializer to output. */
6514 /* Add one non-braced element to the current constructor level.
6515 This adjusts the current position within the constructor's type.
6516 This may also start or terminate implicit levels
6517 to handle a partly-braced initializer.
6519 Once this has found the correct level for the new element,
6520 it calls output_init_element. */
6523 process_init_element (value)
6526 tree orig_value = value;
6527 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6529 designator_depth = 0;
6530 designator_errorneous = 0;
6532 /* Handle superfluous braces around string cst as in
6533 char x[] = {"foo"}; */
6536 && TREE_CODE (constructor_type) == ARRAY_TYPE
6537 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6538 && integer_zerop (constructor_unfilled_index))
6540 if (constructor_stack->replacement_value)
6541 error_init ("excess elements in char array initializer");
6542 constructor_stack->replacement_value = value;
6546 if (constructor_stack->replacement_value != 0)
6548 error_init ("excess elements in struct initializer");
6552 /* Ignore elements of a brace group if it is entirely superfluous
6553 and has already been diagnosed. */
6554 if (constructor_type == 0)
6557 /* If we've exhausted any levels that didn't have braces,
6559 while (constructor_stack->implicit)
6561 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6562 || TREE_CODE (constructor_type) == UNION_TYPE)
6563 && constructor_fields == 0)
6564 process_init_element (pop_init_level (1));
6565 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6566 && (constructor_max_index == 0
6567 || tree_int_cst_lt (constructor_max_index,
6568 constructor_index)))
6569 process_init_element (pop_init_level (1));
6574 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6575 if (constructor_range_stack)
6577 /* If value is a compound literal and we'll be just using its
6578 content, don't put it into a SAVE_EXPR. */
6579 if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
6580 || !require_constant_value
6582 value = save_expr (value);
6587 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6590 enum tree_code fieldcode;
6592 if (constructor_fields == 0)
6594 pedwarn_init ("excess elements in struct initializer");
6598 fieldtype = TREE_TYPE (constructor_fields);
6599 if (fieldtype != error_mark_node)
6600 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6601 fieldcode = TREE_CODE (fieldtype);
6603 /* Error for non-static initialization of a flexible array member. */
6604 if (fieldcode == ARRAY_TYPE
6605 && !require_constant_value
6606 && TYPE_SIZE (fieldtype) == NULL_TREE
6607 && TREE_CHAIN (constructor_fields) == NULL_TREE)
6609 error_init ("non-static initialization of a flexible array member");
6613 /* Accept a string constant to initialize a subarray. */
6615 && fieldcode == ARRAY_TYPE
6616 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6619 /* Otherwise, if we have come to a subaggregate,
6620 and we don't have an element of its type, push into it. */
6621 else if (value != 0 && !constructor_no_implicit
6622 && value != error_mark_node
6623 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6624 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6625 || fieldcode == UNION_TYPE))
6627 push_init_level (1);
6633 push_member_name (constructor_fields);
6634 output_init_element (value, fieldtype, constructor_fields, 1);
6635 RESTORE_SPELLING_DEPTH (constructor_depth);
6638 /* Do the bookkeeping for an element that was
6639 directly output as a constructor. */
6641 /* For a record, keep track of end position of last field. */
6642 if (DECL_SIZE (constructor_fields))
6643 constructor_bit_index
6644 = size_binop (PLUS_EXPR,
6645 bit_position (constructor_fields),
6646 DECL_SIZE (constructor_fields));
6648 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6649 /* Skip any nameless bit fields. */
6650 while (constructor_unfilled_fields != 0
6651 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6652 && DECL_NAME (constructor_unfilled_fields) == 0)
6653 constructor_unfilled_fields =
6654 TREE_CHAIN (constructor_unfilled_fields);
6657 constructor_fields = TREE_CHAIN (constructor_fields);
6658 /* Skip any nameless bit fields at the beginning. */
6659 while (constructor_fields != 0
6660 && DECL_C_BIT_FIELD (constructor_fields)
6661 && DECL_NAME (constructor_fields) == 0)
6662 constructor_fields = TREE_CHAIN (constructor_fields);
6664 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6667 enum tree_code fieldcode;
6669 if (constructor_fields == 0)
6671 pedwarn_init ("excess elements in union initializer");
6675 fieldtype = TREE_TYPE (constructor_fields);
6676 if (fieldtype != error_mark_node)
6677 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6678 fieldcode = TREE_CODE (fieldtype);
6680 /* Warn that traditional C rejects initialization of unions.
6681 We skip the warning if the value is zero. This is done
6682 under the assumption that the zero initializer in user
6683 code appears conditioned on e.g. __STDC__ to avoid
6684 "missing initializer" warnings and relies on default
6685 initialization to zero in the traditional C case.
6686 We also skip the warning if the initializer is designated,
6687 again on the assumption that this must be conditional on
6688 __STDC__ anyway (and we've already complained about the
6689 member-designator already). */
6690 if (warn_traditional && !in_system_header && !constructor_designated
6691 && !(value && (integer_zerop (value) || real_zerop (value))))
6692 warning ("traditional C rejects initialization of unions");
6694 /* Accept a string constant to initialize a subarray. */
6696 && fieldcode == ARRAY_TYPE
6697 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6700 /* Otherwise, if we have come to a subaggregate,
6701 and we don't have an element of its type, push into it. */
6702 else if (value != 0 && !constructor_no_implicit
6703 && value != error_mark_node
6704 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6705 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6706 || fieldcode == UNION_TYPE))
6708 push_init_level (1);
6714 push_member_name (constructor_fields);
6715 output_init_element (value, fieldtype, constructor_fields, 1);
6716 RESTORE_SPELLING_DEPTH (constructor_depth);
6719 /* Do the bookkeeping for an element that was
6720 directly output as a constructor. */
6722 constructor_bit_index = DECL_SIZE (constructor_fields);
6723 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6726 constructor_fields = 0;
6728 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6730 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6731 enum tree_code eltcode = TREE_CODE (elttype);
6733 /* Accept a string constant to initialize a subarray. */
6735 && eltcode == ARRAY_TYPE
6736 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6739 /* Otherwise, if we have come to a subaggregate,
6740 and we don't have an element of its type, push into it. */
6741 else if (value != 0 && !constructor_no_implicit
6742 && value != error_mark_node
6743 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6744 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6745 || eltcode == UNION_TYPE))
6747 push_init_level (1);
6751 if (constructor_max_index != 0
6752 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6753 || integer_all_onesp (constructor_max_index)))
6755 pedwarn_init ("excess elements in array initializer");
6759 /* Now output the actual element. */
6762 push_array_bounds (tree_low_cst (constructor_index, 0));
6763 output_init_element (value, elttype, constructor_index, 1);
6764 RESTORE_SPELLING_DEPTH (constructor_depth);
6768 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6771 /* If we are doing the bookkeeping for an element that was
6772 directly output as a constructor, we must update
6773 constructor_unfilled_index. */
6774 constructor_unfilled_index = constructor_index;
6776 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6778 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6780 /* Do a basic check of initializer size. Note that vectors
6781 always have a fixed size derived from their type. */
6782 if (tree_int_cst_lt (constructor_max_index, constructor_index))
6784 pedwarn_init ("excess elements in vector initializer");
6788 /* Now output the actual element. */
6790 output_init_element (value, elttype, constructor_index, 1);
6793 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6796 /* If we are doing the bookkeeping for an element that was
6797 directly output as a constructor, we must update
6798 constructor_unfilled_index. */
6799 constructor_unfilled_index = constructor_index;
6802 /* Handle the sole element allowed in a braced initializer
6803 for a scalar variable. */
6804 else if (constructor_fields == 0)
6806 pedwarn_init ("excess elements in scalar initializer");
6812 output_init_element (value, constructor_type, NULL_TREE, 1);
6813 constructor_fields = 0;
6816 /* Handle range initializers either at this level or anywhere higher
6817 in the designator stack. */
6818 if (constructor_range_stack)
6820 struct constructor_range_stack *p, *range_stack;
6823 range_stack = constructor_range_stack;
6824 constructor_range_stack = 0;
6825 while (constructor_stack != range_stack->stack)
6827 if (!constructor_stack->implicit)
6829 process_init_element (pop_init_level (1));
6831 for (p = range_stack;
6832 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6835 if (!constructor_stack->implicit)
6837 process_init_element (pop_init_level (1));
6840 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6841 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6846 constructor_index = p->index;
6847 constructor_fields = p->fields;
6848 if (finish && p->range_end && p->index == p->range_start)
6856 push_init_level (2);
6857 p->stack = constructor_stack;
6858 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6859 p->index = p->range_start;
6863 constructor_range_stack = range_stack;
6870 constructor_range_stack = 0;
6873 /* Build a simple asm-statement, from one string literal. */
6875 simple_asm_stmt (expr)
6880 if (TREE_CODE (expr) == ADDR_EXPR)
6881 expr = TREE_OPERAND (expr, 0);
6883 if (TREE_CODE (expr) == STRING_CST)
6887 if (TREE_CHAIN (expr))
6888 expr = combine_strings (expr);
6889 stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6890 NULL_TREE, NULL_TREE,
6892 ASM_INPUT_P (stmt) = 1;
6896 error ("argument of `asm' is not a constant string");
6900 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6901 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6904 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6913 if (TREE_CHAIN (string))
6914 string = combine_strings (string);
6915 if (TREE_CODE (string) != STRING_CST)
6917 error ("asm template is not a string constant");
6921 if (cv_qualifier != NULL_TREE
6922 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6924 warning ("%s qualifier ignored on asm",
6925 IDENTIFIER_POINTER (cv_qualifier));
6926 cv_qualifier = NULL_TREE;
6929 /* We can remove output conversions that change the type,
6930 but not the mode. */
6931 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6933 tree output = TREE_VALUE (tail);
6935 STRIP_NOPS (output);
6936 TREE_VALUE (tail) = output;
6938 /* Allow conversions as LHS here. build_modify_expr as called below
6939 will do the right thing with them. */
6940 while (TREE_CODE (output) == NOP_EXPR
6941 || TREE_CODE (output) == CONVERT_EXPR
6942 || TREE_CODE (output) == FLOAT_EXPR
6943 || TREE_CODE (output) == FIX_TRUNC_EXPR
6944 || TREE_CODE (output) == FIX_FLOOR_EXPR
6945 || TREE_CODE (output) == FIX_ROUND_EXPR
6946 || TREE_CODE (output) == FIX_CEIL_EXPR)
6947 output = TREE_OPERAND (output, 0);
6949 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6952 /* Remove output conversions that change the type but not the mode. */
6953 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6955 tree output = TREE_VALUE (tail);
6956 STRIP_NOPS (output);
6957 TREE_VALUE (tail) = output;
6960 /* Perform default conversions on array and function inputs.
6961 Don't do this for other types as it would screw up operands
6962 expected to be in memory. */
6963 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6964 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6966 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6967 outputs, inputs, clobbers));
6970 /* Expand an ASM statement with operands, handling output operands
6971 that are not variables or INDIRECT_REFS by transforming such
6972 cases into cases that expand_asm_operands can handle.
6974 Arguments are same as for expand_asm_operands. */
6977 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6978 tree string, outputs, inputs, clobbers;
6980 const char *filename;
6983 int noutputs = list_length (outputs);
6985 /* o[I] is the place that output number I should be written. */
6986 tree *o = (tree *) alloca (noutputs * sizeof (tree));
6989 /* Record the contents of OUTPUTS before it is modified. */
6990 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6991 o[i] = TREE_VALUE (tail);
6993 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6994 OUTPUTS some trees for where the values were actually stored. */
6995 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6997 /* Copy all the intermediate outputs into the specified outputs. */
6998 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
7000 if (o[i] != TREE_VALUE (tail))
7002 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
7003 NULL_RTX, VOIDmode, EXPAND_NORMAL);
7006 /* Restore the original value so that it's correct the next
7007 time we expand this function. */
7008 TREE_VALUE (tail) = o[i];
7010 /* Detect modification of read-only values.
7011 (Otherwise done by build_modify_expr.) */
7014 tree type = TREE_TYPE (o[i]);
7015 if (TREE_READONLY (o[i])
7016 || TYPE_READONLY (type)
7017 || ((TREE_CODE (type) == RECORD_TYPE
7018 || TREE_CODE (type) == UNION_TYPE)
7019 && C_TYPE_FIELDS_READONLY (type)))
7020 readonly_warning (o[i], "modification by `asm'");
7024 /* Those MODIFY_EXPRs could do autoincrements. */
7028 /* Expand a C `return' statement.
7029 RETVAL is the expression for what to return,
7030 or a null pointer for `return;' with no value. */
7033 c_expand_return (retval)
7036 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
7038 if (TREE_THIS_VOLATILE (current_function_decl))
7039 warning ("function declared `noreturn' has a `return' statement");
7043 current_function_returns_null = 1;
7044 if ((warn_return_type || flag_isoc99)
7045 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7046 pedwarn_c99 ("`return' with no value, in function returning non-void");
7048 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7050 current_function_returns_null = 1;
7051 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7052 pedwarn ("`return' with a value, in function returning void");
7056 tree t = convert_for_assignment (valtype, retval, _("return"),
7057 NULL_TREE, NULL_TREE, 0);
7058 tree res = DECL_RESULT (current_function_decl);
7061 current_function_returns_value = 1;
7062 if (t == error_mark_node)
7065 inner = t = convert (TREE_TYPE (res), t);
7067 /* Strip any conversions, additions, and subtractions, and see if
7068 we are returning the address of a local variable. Warn if so. */
7071 switch (TREE_CODE (inner))
7073 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
7075 inner = TREE_OPERAND (inner, 0);
7079 /* If the second operand of the MINUS_EXPR has a pointer
7080 type (or is converted from it), this may be valid, so
7081 don't give a warning. */
7083 tree op1 = TREE_OPERAND (inner, 1);
7085 while (! POINTER_TYPE_P (TREE_TYPE (op1))
7086 && (TREE_CODE (op1) == NOP_EXPR
7087 || TREE_CODE (op1) == NON_LVALUE_EXPR
7088 || TREE_CODE (op1) == CONVERT_EXPR))
7089 op1 = TREE_OPERAND (op1, 0);
7091 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7094 inner = TREE_OPERAND (inner, 0);
7099 inner = TREE_OPERAND (inner, 0);
7101 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7102 inner = TREE_OPERAND (inner, 0);
7104 if (TREE_CODE (inner) == VAR_DECL
7105 && ! DECL_EXTERNAL (inner)
7106 && ! TREE_STATIC (inner)
7107 && DECL_CONTEXT (inner) == current_function_decl)
7108 warning ("function returns address of local variable");
7118 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7121 return add_stmt (build_return_stmt (retval));
7125 /* The SWITCH_STMT being built. */
7127 /* A splay-tree mapping the low element of a case range to the high
7128 element, or NULL_TREE if there is no high element. Used to
7129 determine whether or not a new case label duplicates an old case
7130 label. We need a tree, rather than simply a hash table, because
7131 of the GNU case range extension. */
7133 /* The next node on the stack. */
7134 struct c_switch *next;
7137 /* A stack of the currently active switch statements. The innermost
7138 switch statement is on the top of the stack. There is no need to
7139 mark the stack for garbage collection because it is only active
7140 during the processing of the body of a function, and we never
7141 collect at that point. */
7143 static struct c_switch *switch_stack;
7145 /* Start a C switch statement, testing expression EXP. Return the new
7152 enum tree_code code;
7153 tree type, orig_type = error_mark_node;
7154 struct c_switch *cs;
7156 if (exp != error_mark_node)
7158 code = TREE_CODE (TREE_TYPE (exp));
7159 orig_type = TREE_TYPE (exp);
7161 if (! INTEGRAL_TYPE_P (orig_type)
7162 && code != ERROR_MARK)
7164 error ("switch quantity not an integer");
7165 exp = integer_zero_node;
7169 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7171 if (warn_traditional && !in_system_header
7172 && (type == long_integer_type_node
7173 || type == long_unsigned_type_node))
7174 warning ("`long' switch expression not converted to `int' in ISO C");
7176 exp = default_conversion (exp);
7177 type = TREE_TYPE (exp);
7181 /* Add this new SWITCH_STMT to the stack. */
7182 cs = (struct c_switch *) xmalloc (sizeof (*cs));
7183 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
7184 cs->cases = splay_tree_new (case_compare, NULL, NULL);
7185 cs->next = switch_stack;
7188 return add_stmt (switch_stack->switch_stmt);
7191 /* Process a case label. */
7194 do_case (low_value, high_value)
7198 tree label = NULL_TREE;
7202 label = c_add_case_label (switch_stack->cases,
7203 SWITCH_COND (switch_stack->switch_stmt),
7204 low_value, high_value);
7205 if (label == error_mark_node)
7209 error ("case label not within a switch statement");
7211 error ("`default' label not within a switch statement");
7216 /* Finish the switch statement. */
7221 struct c_switch *cs = switch_stack;
7223 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7225 /* Pop the stack. */
7226 switch_stack = switch_stack->next;
7227 splay_tree_delete (cs->cases);