1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is part of the C front end.
24 It contains routines to build C expressions given their operands,
25 including computing the types of the result, C-specific error checks,
26 and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
46 /* Nonzero if we've already printed a "missing braces around initializer"
47 message within this initializer. */
48 static int missing_braces_mentioned;
50 /* 1 if we explained undeclared var errors. */
51 static int undeclared_variable_notice;
53 static tree qualify_type PARAMS ((tree, tree));
54 static int comp_target_types PARAMS ((tree, tree));
55 static int function_types_compatible_p PARAMS ((tree, tree));
56 static int type_lists_compatible_p PARAMS ((tree, tree));
57 static tree decl_constant_value_for_broken_optimization PARAMS ((tree));
58 static tree lookup_field PARAMS ((tree, tree, tree *));
59 static tree convert_arguments PARAMS ((tree, tree, tree, tree));
60 static tree pointer_int_sum PARAMS ((enum tree_code, tree, tree));
61 static tree pointer_diff PARAMS ((tree, tree));
62 static tree unary_complex_lvalue PARAMS ((enum tree_code, tree));
63 static void pedantic_lvalue_warning PARAMS ((enum tree_code));
64 static tree internal_build_compound_expr PARAMS ((tree, int));
65 static tree convert_for_assignment PARAMS ((tree, tree, const char *,
67 static void warn_for_assignment PARAMS ((const char *, const char *,
69 static tree valid_compound_expr_initializer PARAMS ((tree, tree));
70 static void push_string PARAMS ((const char *));
71 static void push_member_name PARAMS ((tree));
72 static void push_array_bounds PARAMS ((int));
73 static int spelling_length PARAMS ((void));
74 static char *print_spelling PARAMS ((char *));
75 static void warning_init PARAMS ((const char *));
76 static tree digest_init PARAMS ((tree, tree, int, int));
77 static void output_init_element PARAMS ((tree, tree, tree, int));
78 static void output_pending_init_elements PARAMS ((int));
79 static int set_designator PARAMS ((int));
80 static void push_range_stack PARAMS ((tree));
81 static void add_pending_init PARAMS ((tree, tree));
82 static void set_nonincremental_init PARAMS ((void));
83 static void set_nonincremental_init_from_string PARAMS ((tree));
84 static tree find_init_member PARAMS ((tree));
86 /* Do `exp = require_complete_type (exp);' to make sure exp
87 does not have an incomplete type. (That includes void types.) */
90 require_complete_type (value)
93 tree type = TREE_TYPE (value);
95 if (TREE_CODE (value) == ERROR_MARK)
96 return error_mark_node;
98 /* First, detect a valid value with a complete type. */
99 if (COMPLETE_TYPE_P (type))
102 incomplete_type_error (value, type);
103 return error_mark_node;
106 /* Print an error message for invalid use of an incomplete type.
107 VALUE is the expression that was used (or 0 if that isn't known)
108 and TYPE is the type that was invalid. */
111 incomplete_type_error (value, type)
115 const char *type_code_string;
117 /* Avoid duplicate error message. */
118 if (TREE_CODE (type) == ERROR_MARK)
121 if (value != 0 && (TREE_CODE (value) == VAR_DECL
122 || TREE_CODE (value) == PARM_DECL))
123 error ("`%s' has an incomplete type",
124 IDENTIFIER_POINTER (DECL_NAME (value)));
128 /* We must print an error message. Be clever about what it says. */
130 switch (TREE_CODE (type))
133 type_code_string = "struct";
137 type_code_string = "union";
141 type_code_string = "enum";
145 error ("invalid use of void expression");
149 if (TYPE_DOMAIN (type))
151 type = TREE_TYPE (type);
154 error ("invalid use of array with unspecified bounds");
161 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
162 error ("invalid use of undefined type `%s %s'",
163 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
165 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
166 error ("invalid use of incomplete typedef `%s'",
167 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
171 /* Return a variant of TYPE which has all the type qualifiers of LIKE
172 as well as those of TYPE. */
175 qualify_type (type, like)
178 return c_build_qualified_type (type,
179 TYPE_QUALS (type) | TYPE_QUALS (like));
182 /* Return the common type of two types.
183 We assume that comptypes has already been done and returned 1;
184 if that isn't so, this may crash. In particular, we assume that qualifiers
187 This is the type for the result of most arithmetic operations
188 if the operands have the given two types. */
194 register enum tree_code code1;
195 register enum tree_code code2;
198 /* Save time if the two types are the same. */
200 if (t1 == t2) return t1;
202 /* If one type is nonsense, use the other. */
203 if (t1 == error_mark_node)
205 if (t2 == error_mark_node)
208 /* Merge the attributes. */
209 attributes = (*targetm.merge_type_attributes) (t1, t2);
211 /* Treat an enum type as the unsigned integer type of the same width. */
213 if (TREE_CODE (t1) == ENUMERAL_TYPE)
214 t1 = type_for_size (TYPE_PRECISION (t1), 1);
215 if (TREE_CODE (t2) == ENUMERAL_TYPE)
216 t2 = type_for_size (TYPE_PRECISION (t2), 1);
218 code1 = TREE_CODE (t1);
219 code2 = TREE_CODE (t2);
221 /* If one type is complex, form the common type of the non-complex
222 components, then make that complex. Use T1 or T2 if it is the
224 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
226 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
227 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
228 tree subtype = common_type (subtype1, subtype2);
230 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
231 return build_type_attribute_variant (t1, attributes);
232 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
233 return build_type_attribute_variant (t2, attributes);
235 return build_type_attribute_variant (build_complex_type (subtype),
243 /* If only one is real, use it as the result. */
245 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
246 return build_type_attribute_variant (t1, attributes);
248 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
249 return build_type_attribute_variant (t2, attributes);
251 /* Both real or both integers; use the one with greater precision. */
253 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
254 return build_type_attribute_variant (t1, attributes);
255 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
256 return build_type_attribute_variant (t2, attributes);
258 /* Same precision. Prefer longs to ints even when same size. */
260 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
261 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
262 return build_type_attribute_variant (long_unsigned_type_node,
265 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
266 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
268 /* But preserve unsignedness from the other type,
269 since long cannot hold all the values of an unsigned int. */
270 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
271 t1 = long_unsigned_type_node;
273 t1 = long_integer_type_node;
274 return build_type_attribute_variant (t1, attributes);
277 /* Likewise, prefer long double to double even if same size. */
278 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
279 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
280 return build_type_attribute_variant (long_double_type_node,
283 /* Otherwise prefer the unsigned one. */
285 if (TREE_UNSIGNED (t1))
286 return build_type_attribute_variant (t1, attributes);
288 return build_type_attribute_variant (t2, attributes);
291 /* For two pointers, do this recursively on the target type,
292 and combine the qualifiers of the two types' targets. */
293 /* This code was turned off; I don't know why.
294 But ANSI C specifies doing this with the qualifiers.
295 So I turned it on again. */
297 tree pointed_to_1 = TREE_TYPE (t1);
298 tree pointed_to_2 = TREE_TYPE (t2);
299 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
300 TYPE_MAIN_VARIANT (pointed_to_2));
301 t1 = build_pointer_type (c_build_qualified_type
303 TYPE_QUALS (pointed_to_1) |
304 TYPE_QUALS (pointed_to_2)));
305 return build_type_attribute_variant (t1, attributes);
308 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
309 return build_type_attribute_variant (t1, attributes);
314 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
315 /* Save space: see if the result is identical to one of the args. */
316 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
317 return build_type_attribute_variant (t1, attributes);
318 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
319 return build_type_attribute_variant (t2, attributes);
320 /* Merge the element types, and have a size if either arg has one. */
321 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
322 return build_type_attribute_variant (t1, attributes);
326 /* Function types: prefer the one that specified arg types.
327 If both do, merge the arg types. Also merge the return types. */
329 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
330 tree p1 = TYPE_ARG_TYPES (t1);
331 tree p2 = TYPE_ARG_TYPES (t2);
336 /* Save space: see if the result is identical to one of the args. */
337 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
338 return build_type_attribute_variant (t1, attributes);
339 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
340 return build_type_attribute_variant (t2, attributes);
342 /* Simple way if one arg fails to specify argument types. */
343 if (TYPE_ARG_TYPES (t1) == 0)
345 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
346 return build_type_attribute_variant (t1, attributes);
348 if (TYPE_ARG_TYPES (t2) == 0)
350 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
351 return build_type_attribute_variant (t1, attributes);
354 /* If both args specify argument types, we must merge the two
355 lists, argument by argument. */
358 declare_parm_level (1);
360 len = list_length (p1);
363 for (i = 0; i < len; i++)
364 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
369 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
371 /* A null type means arg type is not specified.
372 Take whatever the other function type has. */
373 if (TREE_VALUE (p1) == 0)
375 TREE_VALUE (n) = TREE_VALUE (p2);
378 if (TREE_VALUE (p2) == 0)
380 TREE_VALUE (n) = TREE_VALUE (p1);
384 /* Given wait (union {union wait *u; int *i} *)
385 and wait (union wait *),
386 prefer union wait * as type of parm. */
387 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
388 && TREE_VALUE (p1) != TREE_VALUE (p2))
391 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
392 memb; memb = TREE_CHAIN (memb))
393 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
395 TREE_VALUE (n) = TREE_VALUE (p2);
397 pedwarn ("function types not truly compatible in ISO C");
401 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
402 && TREE_VALUE (p2) != TREE_VALUE (p1))
405 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
406 memb; memb = TREE_CHAIN (memb))
407 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
409 TREE_VALUE (n) = TREE_VALUE (p1);
411 pedwarn ("function types not truly compatible in ISO C");
415 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
421 t1 = build_function_type (valtype, newargs);
422 /* ... falls through ... */
426 return build_type_attribute_variant (t1, attributes);
431 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
432 or various other operations. Return 2 if they are compatible
433 but a warning may be needed if you use them together. */
436 comptypes (type1, type2)
439 register tree t1 = type1;
440 register tree t2 = type2;
443 /* Suppress errors caused by previously reported errors. */
445 if (t1 == t2 || !t1 || !t2
446 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
449 /* If either type is the internal version of sizetype, return the
451 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
452 && TYPE_DOMAIN (t1) != 0)
453 t1 = TYPE_DOMAIN (t1);
455 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
456 && TYPE_DOMAIN (t2) != 0)
457 t2 = TYPE_DOMAIN (t2);
459 /* Treat an enum type as the integer type of the same width and
462 if (TREE_CODE (t1) == ENUMERAL_TYPE)
463 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
464 if (TREE_CODE (t2) == ENUMERAL_TYPE)
465 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
470 /* Different classes of types can't be compatible. */
472 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
474 /* Qualifiers must match. */
476 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
479 /* Allow for two different type nodes which have essentially the same
480 definition. Note that we already checked for equality of the type
481 qualifiers (just above). */
483 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
486 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
487 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
490 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
493 switch (TREE_CODE (t1))
496 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
497 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
501 val = function_types_compatible_p (t1, t2);
506 tree d1 = TYPE_DOMAIN (t1);
507 tree d2 = TYPE_DOMAIN (t2);
510 /* Target types must match incl. qualifiers. */
511 if (TREE_TYPE (t1) != TREE_TYPE (t2)
512 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
515 /* Sizes must match unless one is missing or variable. */
516 if (d1 == 0 || d2 == 0 || d1 == d2
517 || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
518 || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
519 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
520 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
523 if (! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
524 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
531 if (maybe_objc_comptypes (t1, t2, 0) == 1)
538 return attrval == 2 && val == 1 ? 2 : val;
541 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
542 ignoring their qualifiers. */
545 comp_target_types (ttl, ttr)
550 /* Give maybe_objc_comptypes a crack at letting these types through. */
551 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
554 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
555 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
557 if (val == 2 && pedantic)
558 pedwarn ("types are not quite compatible");
562 /* Subroutines of `comptypes'. */
564 /* Return 1 if two function types F1 and F2 are compatible.
565 If either type specifies no argument types,
566 the other must specify a fixed number of self-promoting arg types.
567 Otherwise, if one type specifies only the number of arguments,
568 the other must specify that number of self-promoting arg types.
569 Otherwise, the argument types must match. */
572 function_types_compatible_p (f1, f2)
576 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
580 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
581 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
584 args1 = TYPE_ARG_TYPES (f1);
585 args2 = TYPE_ARG_TYPES (f2);
587 /* An unspecified parmlist matches any specified parmlist
588 whose argument types don't need default promotions. */
592 if (!self_promoting_args_p (args2))
594 /* If one of these types comes from a non-prototype fn definition,
595 compare that with the other type's arglist.
596 If they don't match, ask for a warning (but no error). */
597 if (TYPE_ACTUAL_ARG_TYPES (f1)
598 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
604 if (!self_promoting_args_p (args1))
606 if (TYPE_ACTUAL_ARG_TYPES (f2)
607 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
612 /* Both types have argument lists: compare them and propagate results. */
613 val1 = type_lists_compatible_p (args1, args2);
614 return val1 != 1 ? val1 : val;
617 /* Check two lists of types for compatibility,
618 returning 0 for incompatible, 1 for compatible,
619 or 2 for compatible with warning. */
622 type_lists_compatible_p (args1, args2)
625 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
631 if (args1 == 0 && args2 == 0)
633 /* If one list is shorter than the other,
634 they fail to match. */
635 if (args1 == 0 || args2 == 0)
637 /* A null pointer instead of a type
638 means there is supposed to be an argument
639 but nothing is specified about what type it has.
640 So match anything that self-promotes. */
641 if (TREE_VALUE (args1) == 0)
643 if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE)
646 else if (TREE_VALUE (args2) == 0)
648 if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE)
651 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
652 TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
654 /* Allow wait (union {union wait *u; int *i} *)
655 and wait (union wait *) to be compatible. */
656 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
657 && (TYPE_NAME (TREE_VALUE (args1)) == 0
658 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
659 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
660 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
661 TYPE_SIZE (TREE_VALUE (args2))))
664 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
665 memb; memb = TREE_CHAIN (memb))
666 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
671 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
672 && (TYPE_NAME (TREE_VALUE (args2)) == 0
673 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
674 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
675 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
676 TYPE_SIZE (TREE_VALUE (args1))))
679 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
680 memb; memb = TREE_CHAIN (memb))
681 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
690 /* comptypes said ok, but record if it said to warn. */
694 args1 = TREE_CHAIN (args1);
695 args2 = TREE_CHAIN (args2);
699 /* Compute the value of the `sizeof' operator. */
705 enum tree_code code = TREE_CODE (type);
708 if (code == FUNCTION_TYPE)
710 if (pedantic || warn_pointer_arith)
711 pedwarn ("sizeof applied to a function type");
712 size = size_one_node;
714 else if (code == VOID_TYPE)
716 if (pedantic || warn_pointer_arith)
717 pedwarn ("sizeof applied to a void type");
718 size = size_one_node;
720 else if (code == ERROR_MARK)
721 size = size_one_node;
722 else if (!COMPLETE_TYPE_P (type))
724 error ("sizeof applied to an incomplete type");
725 size = size_zero_node;
728 /* Convert in case a char is more than one unit. */
729 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
730 size_int (TYPE_PRECISION (char_type_node)
733 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
734 TYPE_IS_SIZETYPE means that certain things (like overflow) will
735 never happen. However, this node should really have type
736 `size_t', which is just a typedef for an ordinary integer type. */
737 return fold (build1 (NOP_EXPR, c_size_type_node, size));
741 c_sizeof_nowarn (type)
744 enum tree_code code = TREE_CODE (type);
747 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
748 size = size_one_node;
749 else if (!COMPLETE_TYPE_P (type))
750 size = size_zero_node;
752 /* Convert in case a char is more than one unit. */
753 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
754 size_int (TYPE_PRECISION (char_type_node)
757 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
758 TYPE_IS_SIZETYPE means that certain things (like overflow) will
759 never happen. However, this node should really have type
760 `size_t', which is just a typedef for an ordinary integer type. */
761 return fold (build1 (NOP_EXPR, c_size_type_node, size));
764 /* Compute the size to increment a pointer by. */
767 c_size_in_bytes (type)
770 enum tree_code code = TREE_CODE (type);
772 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
773 return size_one_node;
775 if (!COMPLETE_OR_VOID_TYPE_P (type))
777 error ("arithmetic on pointer to an incomplete type");
778 return size_one_node;
781 /* Convert in case a char is more than one unit. */
782 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
783 size_int (TYPE_PRECISION (char_type_node)
787 /* Implement the __alignof keyword: Return the minimum required
788 alignment of TYPE, measured in bytes. */
794 enum tree_code code = TREE_CODE (type);
797 if (code == FUNCTION_TYPE)
798 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
799 else if (code == VOID_TYPE || code == ERROR_MARK)
801 else if (code == ERROR_MARK)
803 else if (!COMPLETE_TYPE_P (type))
805 error ("__alignof__ applied to an incomplete type");
809 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
811 return fold (build1 (NOP_EXPR, c_size_type_node, t));
814 /* Implement the __alignof keyword: Return the minimum required
815 alignment of EXPR, measured in bytes. For VAR_DECL's and
816 FIELD_DECL's return DECL_ALIGN (which can be set from an
817 "aligned" __attribute__ specification). */
820 c_alignof_expr (expr)
825 if (TREE_CODE (expr) == VAR_DECL)
826 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
828 else if (TREE_CODE (expr) == COMPONENT_REF
829 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
831 error ("`__alignof' applied to a bit-field");
834 else if (TREE_CODE (expr) == COMPONENT_REF
835 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
836 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
838 else if (TREE_CODE (expr) == INDIRECT_REF)
840 tree t = TREE_OPERAND (expr, 0);
842 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
844 while (TREE_CODE (t) == NOP_EXPR
845 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
849 t = TREE_OPERAND (t, 0);
850 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
851 if (thisalign > bestalign)
852 best = t, bestalign = thisalign;
854 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
857 return c_alignof (TREE_TYPE (expr));
859 return fold (build1 (NOP_EXPR, c_size_type_node, t));
862 /* Return either DECL or its known constant value (if it has one). */
865 decl_constant_value (decl)
868 if (/* Don't change a variable array bound or initial value to a constant
869 in a place where a variable is invalid. */
870 current_function_decl != 0
871 && ! TREE_THIS_VOLATILE (decl)
872 && TREE_READONLY (decl)
873 && DECL_INITIAL (decl) != 0
874 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
875 /* This is invalid if initial value is not constant.
876 If it has either a function call, a memory reference,
877 or a variable, then re-evaluating it could give different results. */
878 && TREE_CONSTANT (DECL_INITIAL (decl))
879 /* Check for cases where this is sub-optimal, even though valid. */
880 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
881 return DECL_INITIAL (decl);
885 /* Return either DECL or its known constant value (if it has one), but
886 return DECL if pedantic or DECL has mode BLKmode. This is for
887 bug-compatibility with the old behavior of decl_constant_value
888 (before GCC 3.0); every use of this function is a bug and it should
889 be removed before GCC 3.1. It is not appropriate to use pedantic
890 in a way that affects optimization, and BLKmode is probably not the
891 right test for avoiding misoptimizations either. */
894 decl_constant_value_for_broken_optimization (decl)
897 if (pedantic || DECL_MODE (decl) == BLKmode)
900 return decl_constant_value (decl);
903 /* Perform default promotions for C data used in expressions.
904 Arrays and functions are converted to pointers;
905 enumeral types or short or char, to int.
906 In addition, manifest constants symbols are replaced by their values. */
909 default_conversion (exp)
912 register tree type = TREE_TYPE (exp);
913 register enum tree_code code = TREE_CODE (type);
915 /* Constants can be used directly unless they're not loadable. */
916 if (TREE_CODE (exp) == CONST_DECL)
917 exp = DECL_INITIAL (exp);
919 /* Replace a nonvolatile const static variable with its value unless
920 it is an array, in which case we must be sure that taking the
921 address of the array produces consistent results. */
922 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
924 exp = decl_constant_value_for_broken_optimization (exp);
925 type = TREE_TYPE (exp);
928 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
931 Do not use STRIP_NOPS here! It will remove conversions from pointer
932 to integer and cause infinite recursion. */
933 while (TREE_CODE (exp) == NON_LVALUE_EXPR
934 || (TREE_CODE (exp) == NOP_EXPR
935 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
936 exp = TREE_OPERAND (exp, 0);
938 /* Normally convert enums to int,
939 but convert wide enums to something wider. */
940 if (code == ENUMERAL_TYPE)
942 type = type_for_size (MAX (TYPE_PRECISION (type),
943 TYPE_PRECISION (integer_type_node)),
945 || (TYPE_PRECISION (type)
946 >= TYPE_PRECISION (integer_type_node)))
947 && TREE_UNSIGNED (type)));
949 return convert (type, exp);
952 if (TREE_CODE (exp) == COMPONENT_REF
953 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
954 /* If it's thinner than an int, promote it like a
955 c_promoting_integer_type_p, otherwise leave it alone. */
956 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
957 TYPE_PRECISION (integer_type_node)))
958 return convert (flag_traditional && TREE_UNSIGNED (type)
959 ? unsigned_type_node : integer_type_node,
962 if (c_promoting_integer_type_p (type))
964 /* Traditionally, unsignedness is preserved in default promotions.
965 Also preserve unsignedness if not really getting any wider. */
966 if (TREE_UNSIGNED (type)
968 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
969 return convert (unsigned_type_node, exp);
971 return convert (integer_type_node, exp);
974 if (flag_traditional && !flag_allow_single_precision
975 && TYPE_MAIN_VARIANT (type) == float_type_node)
976 return convert (double_type_node, exp);
978 if (code == VOID_TYPE)
980 error ("void value not ignored as it ought to be");
981 return error_mark_node;
983 if (code == FUNCTION_TYPE)
985 return build_unary_op (ADDR_EXPR, exp, 0);
987 if (code == ARRAY_TYPE)
990 tree restype = TREE_TYPE (type);
995 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
997 constp = TREE_READONLY (exp);
998 volatilep = TREE_THIS_VOLATILE (exp);
1001 if (TYPE_QUALS (type) || constp || volatilep)
1003 = c_build_qualified_type (restype,
1005 | (constp * TYPE_QUAL_CONST)
1006 | (volatilep * TYPE_QUAL_VOLATILE));
1008 if (TREE_CODE (exp) == INDIRECT_REF)
1009 return convert (TYPE_POINTER_TO (restype),
1010 TREE_OPERAND (exp, 0));
1012 if (TREE_CODE (exp) == COMPOUND_EXPR)
1014 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1015 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1016 TREE_OPERAND (exp, 0), op1);
1019 if (! lvalue_p (exp)
1020 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1022 error ("invalid use of non-lvalue array");
1023 return error_mark_node;
1026 ptrtype = build_pointer_type (restype);
1028 if (TREE_CODE (exp) == VAR_DECL)
1030 /* ??? This is not really quite correct
1031 in that the type of the operand of ADDR_EXPR
1032 is not the target type of the type of the ADDR_EXPR itself.
1033 Question is, can this lossage be avoided? */
1034 adr = build1 (ADDR_EXPR, ptrtype, exp);
1035 if (mark_addressable (exp) == 0)
1036 return error_mark_node;
1037 TREE_CONSTANT (adr) = staticp (exp);
1038 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1041 /* This way is better for a COMPONENT_REF since it can
1042 simplify the offset for a component. */
1043 adr = build_unary_op (ADDR_EXPR, exp, 1);
1044 return convert (ptrtype, adr);
1049 /* Look up component name in the structure type definition.
1051 If this component name is found indirectly within an anonymous union,
1052 store in *INDIRECT the component which directly contains
1053 that anonymous union. Otherwise, set *INDIRECT to 0. */
1056 lookup_field (type, component, indirect)
1057 tree type, component;
1062 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1063 to the field elements. Use a binary search on this array to quickly
1064 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1065 will always be set for structures which have many elements. */
1067 if (TYPE_LANG_SPECIFIC (type))
1070 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1072 field = TYPE_FIELDS (type);
1074 top = TYPE_LANG_SPECIFIC (type)->len;
1075 while (top - bot > 1)
1077 half = (top - bot + 1) >> 1;
1078 field = field_array[bot+half];
1080 if (DECL_NAME (field) == NULL_TREE)
1082 /* Step through all anon unions in linear fashion. */
1083 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1085 tree anon = 0, junk;
1087 field = field_array[bot++];
1088 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1089 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1090 anon = lookup_field (TREE_TYPE (field), component, &junk);
1092 if (anon != NULL_TREE)
1099 /* Entire record is only anon unions. */
1103 /* Restart the binary search, with new lower bound. */
1107 if (DECL_NAME (field) == component)
1109 if (DECL_NAME (field) < component)
1115 if (DECL_NAME (field_array[bot]) == component)
1116 field = field_array[bot];
1117 else if (DECL_NAME (field) != component)
1122 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1124 if (DECL_NAME (field) == NULL_TREE)
1129 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1130 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1131 anon = lookup_field (TREE_TYPE (field), component, &junk);
1133 if (anon != NULL_TREE)
1140 if (DECL_NAME (field) == component)
1145 *indirect = NULL_TREE;
1149 /* Make an expression to refer to the COMPONENT field of
1150 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1153 build_component_ref (datum, component)
1154 tree datum, component;
1156 register tree type = TREE_TYPE (datum);
1157 register enum tree_code code = TREE_CODE (type);
1158 register tree field = NULL;
1161 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1162 unless we are not to support things not strictly ANSI. */
1163 switch (TREE_CODE (datum))
1167 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1168 return build (COMPOUND_EXPR, TREE_TYPE (value),
1169 TREE_OPERAND (datum, 0), value);
1172 return build_conditional_expr
1173 (TREE_OPERAND (datum, 0),
1174 build_component_ref (TREE_OPERAND (datum, 1), component),
1175 build_component_ref (TREE_OPERAND (datum, 2), component));
1181 /* See if there is a field or component with name COMPONENT. */
1183 if (code == RECORD_TYPE || code == UNION_TYPE)
1187 if (!COMPLETE_TYPE_P (type))
1189 incomplete_type_error (NULL_TREE, type);
1190 return error_mark_node;
1193 field = lookup_field (type, component, &indirect);
1197 error ("%s has no member named `%s'",
1198 code == RECORD_TYPE ? "structure" : "union",
1199 IDENTIFIER_POINTER (component));
1200 return error_mark_node;
1202 if (TREE_TYPE (field) == error_mark_node)
1203 return error_mark_node;
1205 /* If FIELD was found buried within an anonymous union,
1206 make one COMPONENT_REF to get that anonymous union,
1207 then fall thru to make a second COMPONENT_REF to get FIELD. */
1210 ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1211 if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1212 TREE_READONLY (ref) = 1;
1213 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1214 TREE_THIS_VOLATILE (ref) = 1;
1218 ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1220 if (TREE_READONLY (datum) || TREE_READONLY (field))
1221 TREE_READONLY (ref) = 1;
1222 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1223 TREE_THIS_VOLATILE (ref) = 1;
1227 else if (code != ERROR_MARK)
1228 error ("request for member `%s' in something not a structure or union",
1229 IDENTIFIER_POINTER (component));
1231 return error_mark_node;
1234 /* Given an expression PTR for a pointer, return an expression
1235 for the value pointed to.
1236 ERRORSTRING is the name of the operator to appear in error messages. */
1239 build_indirect_ref (ptr, errorstring)
1241 const char *errorstring;
1243 register tree pointer = default_conversion (ptr);
1244 register tree type = TREE_TYPE (pointer);
1246 if (TREE_CODE (type) == POINTER_TYPE)
1248 if (TREE_CODE (pointer) == ADDR_EXPR
1250 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1251 == TREE_TYPE (type)))
1252 return TREE_OPERAND (pointer, 0);
1255 tree t = TREE_TYPE (type);
1256 register tree ref = build1 (INDIRECT_REF,
1257 TYPE_MAIN_VARIANT (t), pointer);
1259 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1261 error ("dereferencing pointer to incomplete type");
1262 return error_mark_node;
1264 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1265 warning ("dereferencing `void *' pointer");
1267 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1268 so that we get the proper error message if the result is used
1269 to assign to. Also, &* is supposed to be a no-op.
1270 And ANSI C seems to specify that the type of the result
1271 should be the const type. */
1272 /* A de-reference of a pointer to const is not a const. It is valid
1273 to change it via some other pointer. */
1274 TREE_READONLY (ref) = TYPE_READONLY (t);
1275 TREE_SIDE_EFFECTS (ref)
1276 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1277 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1281 else if (TREE_CODE (pointer) != ERROR_MARK)
1282 error ("invalid type argument of `%s'", errorstring);
1283 return error_mark_node;
1286 /* This handles expressions of the form "a[i]", which denotes
1289 This is logically equivalent in C to *(a+i), but we may do it differently.
1290 If A is a variable or a member, we generate a primitive ARRAY_REF.
1291 This avoids forcing the array out of registers, and can work on
1292 arrays that are not lvalues (for example, members of structures returned
1296 build_array_ref (array, index)
1301 error ("subscript missing in array reference");
1302 return error_mark_node;
1305 if (TREE_TYPE (array) == error_mark_node
1306 || TREE_TYPE (index) == error_mark_node)
1307 return error_mark_node;
1309 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1310 && TREE_CODE (array) != INDIRECT_REF)
1314 /* Subscripting with type char is likely to lose
1315 on a machine where chars are signed.
1316 So warn on any machine, but optionally.
1317 Don't warn for unsigned char since that type is safe.
1318 Don't warn for signed char because anyone who uses that
1319 must have done so deliberately. */
1320 if (warn_char_subscripts
1321 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1322 warning ("array subscript has type `char'");
1324 /* Apply default promotions *after* noticing character types. */
1325 index = default_conversion (index);
1327 /* Require integer *after* promotion, for sake of enums. */
1328 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1330 error ("array subscript is not an integer");
1331 return error_mark_node;
1334 /* An array that is indexed by a non-constant
1335 cannot be stored in a register; we must be able to do
1336 address arithmetic on its address.
1337 Likewise an array of elements of variable size. */
1338 if (TREE_CODE (index) != INTEGER_CST
1339 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1340 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1342 if (mark_addressable (array) == 0)
1343 return error_mark_node;
1345 /* An array that is indexed by a constant value which is not within
1346 the array bounds cannot be stored in a register either; because we
1347 would get a crash in store_bit_field/extract_bit_field when trying
1348 to access a non-existent part of the register. */
1349 if (TREE_CODE (index) == INTEGER_CST
1350 && TYPE_VALUES (TREE_TYPE (array))
1351 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1353 if (mark_addressable (array) == 0)
1354 return error_mark_node;
1360 while (TREE_CODE (foo) == COMPONENT_REF)
1361 foo = TREE_OPERAND (foo, 0);
1362 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1363 pedwarn ("ISO C forbids subscripting `register' array");
1364 else if (! flag_isoc99 && ! lvalue_p (foo))
1365 pedwarn ("ISO C89 forbids subscripting non-lvalue array");
1368 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1369 rval = build (ARRAY_REF, type, array, index);
1370 /* Array ref is const/volatile if the array elements are
1371 or if the array is. */
1372 TREE_READONLY (rval)
1373 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1374 | TREE_READONLY (array));
1375 TREE_SIDE_EFFECTS (rval)
1376 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1377 | TREE_SIDE_EFFECTS (array));
1378 TREE_THIS_VOLATILE (rval)
1379 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1380 /* This was added by rms on 16 Nov 91.
1381 It fixes vol struct foo *a; a->elts[1]
1382 in an inline function.
1383 Hope it doesn't break something else. */
1384 | TREE_THIS_VOLATILE (array));
1385 return require_complete_type (fold (rval));
1389 tree ar = default_conversion (array);
1390 tree ind = default_conversion (index);
1392 /* Do the same warning check as above, but only on the part that's
1393 syntactically the index and only if it is also semantically
1395 if (warn_char_subscripts
1396 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1397 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1398 warning ("subscript has type `char'");
1400 /* Put the integer in IND to simplify error checking. */
1401 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1408 if (ar == error_mark_node)
1411 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1412 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1414 error ("subscripted value is neither array nor pointer");
1415 return error_mark_node;
1417 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1419 error ("array subscript is not an integer");
1420 return error_mark_node;
1423 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1428 /* Build an external reference to identifier ID. FUN indicates
1429 whether this will be used for a function call. */
1431 build_external_ref (id, fun)
1436 tree decl = lookup_name (id);
1437 tree objc_ivar = lookup_objc_ivar (id);
1439 if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
1445 if (!decl || decl == error_mark_node)
1446 /* Ordinary implicit function declaration. */
1447 ref = implicitly_declare (id);
1450 /* Implicit declaration of built-in function. Don't
1451 change the built-in declaration, but don't let this
1452 go by silently, either. */
1453 implicit_decl_warning (id);
1455 /* only issue this warning once */
1456 C_DECL_ANTICIPATED (decl) = 0;
1462 /* Reference to undeclared variable, including reference to
1463 builtin outside of function-call context. */
1464 if (current_function_decl == 0)
1465 error ("`%s' undeclared here (not in a function)",
1466 IDENTIFIER_POINTER (id));
1469 if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node
1470 || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl)
1472 error ("`%s' undeclared (first use in this function)",
1473 IDENTIFIER_POINTER (id));
1475 if (! undeclared_variable_notice)
1477 error ("(Each undeclared identifier is reported only once");
1478 error ("for each function it appears in.)");
1479 undeclared_variable_notice = 1;
1482 IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node;
1483 IDENTIFIER_ERROR_LOCUS (id) = current_function_decl;
1485 return error_mark_node;
1490 /* Properly declared variable or function reference. */
1493 else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
1495 warning ("local declaration of `%s' hides instance variable",
1496 IDENTIFIER_POINTER (id));
1503 if (TREE_TYPE (ref) == error_mark_node)
1504 return error_mark_node;
1506 assemble_external (ref);
1507 TREE_USED (ref) = 1;
1509 if (TREE_CODE (ref) == CONST_DECL)
1511 ref = DECL_INITIAL (ref);
1512 TREE_CONSTANT (ref) = 1;
1518 /* Build a function call to function FUNCTION with parameters PARAMS.
1519 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1520 TREE_VALUE of each node is a parameter-expression.
1521 FUNCTION's data type may be a function type or a pointer-to-function. */
1524 build_function_call (function, params)
1525 tree function, params;
1527 register tree fntype, fundecl = 0;
1528 register tree coerced_params;
1529 tree name = NULL_TREE, assembler_name = NULL_TREE, result;
1531 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1532 STRIP_TYPE_NOPS (function);
1534 /* Convert anything with function type to a pointer-to-function. */
1535 if (TREE_CODE (function) == FUNCTION_DECL)
1537 name = DECL_NAME (function);
1538 assembler_name = DECL_ASSEMBLER_NAME (function);
1540 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1541 (because calling an inline function does not mean the function
1542 needs to be separately compiled). */
1543 fntype = build_type_variant (TREE_TYPE (function),
1544 TREE_READONLY (function),
1545 TREE_THIS_VOLATILE (function));
1547 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1550 function = default_conversion (function);
1552 fntype = TREE_TYPE (function);
1554 if (TREE_CODE (fntype) == ERROR_MARK)
1555 return error_mark_node;
1557 if (!(TREE_CODE (fntype) == POINTER_TYPE
1558 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1560 error ("called object is not a function");
1561 return error_mark_node;
1564 /* fntype now gets the type of function pointed to. */
1565 fntype = TREE_TYPE (fntype);
1567 /* Convert the parameters to the types declared in the
1568 function prototype, or apply default promotions. */
1571 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1573 /* Check for errors in format strings. */
1575 if (warn_format && (name || assembler_name))
1576 check_function_format (NULL, name, assembler_name, coerced_params);
1578 /* Recognize certain built-in functions so we can make tree-codes
1579 other than CALL_EXPR. We do this when it enables fold-const.c
1580 to do something useful. */
1582 if (TREE_CODE (function) == ADDR_EXPR
1583 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1584 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1586 result = expand_tree_builtin (TREE_OPERAND (function, 0),
1587 params, coerced_params);
1592 result = build (CALL_EXPR, TREE_TYPE (fntype),
1593 function, coerced_params, NULL_TREE);
1594 TREE_SIDE_EFFECTS (result) = 1;
1595 result = fold (result);
1597 if (VOID_TYPE_P (TREE_TYPE (result)))
1599 return require_complete_type (result);
1602 /* Convert the argument expressions in the list VALUES
1603 to the types in the list TYPELIST. The result is a list of converted
1604 argument expressions.
1606 If TYPELIST is exhausted, or when an element has NULL as its type,
1607 perform the default conversions.
1609 PARMLIST is the chain of parm decls for the function being called.
1610 It may be 0, if that info is not available.
1611 It is used only for generating error messages.
1613 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1615 This is also where warnings about wrong number of args are generated.
1617 Both VALUES and the returned value are chains of TREE_LIST nodes
1618 with the elements of the list in the TREE_VALUE slots of those nodes. */
1621 convert_arguments (typelist, values, name, fundecl)
1622 tree typelist, values, name, fundecl;
1624 register tree typetail, valtail;
1625 register tree result = NULL;
1628 /* Scan the given expressions and types, producing individual
1629 converted arguments and pushing them on RESULT in reverse order. */
1631 for (valtail = values, typetail = typelist, parmnum = 0;
1633 valtail = TREE_CHAIN (valtail), parmnum++)
1635 register tree type = typetail ? TREE_VALUE (typetail) : 0;
1636 register tree val = TREE_VALUE (valtail);
1638 if (type == void_type_node)
1641 error ("too many arguments to function `%s'",
1642 IDENTIFIER_POINTER (name));
1644 error ("too many arguments to function");
1648 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1649 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1650 to convert automatically to a pointer. */
1651 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1652 val = TREE_OPERAND (val, 0);
1654 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1655 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1656 val = default_conversion (val);
1658 val = require_complete_type (val);
1662 /* Formal parm type is specified by a function prototype. */
1665 if (!COMPLETE_TYPE_P (type))
1667 error ("type of formal parameter %d is incomplete", parmnum + 1);
1672 /* Optionally warn about conversions that
1673 differ from the default conversions. */
1674 if (warn_conversion || warn_traditional)
1676 int formal_prec = TYPE_PRECISION (type);
1678 if (INTEGRAL_TYPE_P (type)
1679 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1680 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1681 if (INTEGRAL_TYPE_P (type)
1682 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1683 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1684 else if (TREE_CODE (type) == COMPLEX_TYPE
1685 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1686 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1687 else if (TREE_CODE (type) == REAL_TYPE
1688 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1689 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1690 else if (TREE_CODE (type) == COMPLEX_TYPE
1691 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1692 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1693 else if (TREE_CODE (type) == REAL_TYPE
1694 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1695 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1696 /* ??? At some point, messages should be written about
1697 conversions between complex types, but that's too messy
1699 else if (TREE_CODE (type) == REAL_TYPE
1700 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1702 /* Warn if any argument is passed as `float',
1703 since without a prototype it would be `double'. */
1704 if (formal_prec == TYPE_PRECISION (float_type_node))
1705 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1707 /* Detect integer changing in width or signedness.
1708 These warnings are only activated with
1709 -Wconversion, not with -Wtraditional. */
1710 else if (warn_conversion && INTEGRAL_TYPE_P (type)
1711 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1713 tree would_have_been = default_conversion (val);
1714 tree type1 = TREE_TYPE (would_have_been);
1716 if (TREE_CODE (type) == ENUMERAL_TYPE
1717 && type == TREE_TYPE (val))
1718 /* No warning if function asks for enum
1719 and the actual arg is that enum type. */
1721 else if (formal_prec != TYPE_PRECISION (type1))
1722 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1723 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1725 /* Don't complain if the formal parameter type
1726 is an enum, because we can't tell now whether
1727 the value was an enum--even the same enum. */
1728 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1730 else if (TREE_CODE (val) == INTEGER_CST
1731 && int_fits_type_p (val, type))
1732 /* Change in signedness doesn't matter
1733 if a constant value is unaffected. */
1735 /* Likewise for a constant in a NOP_EXPR. */
1736 else if (TREE_CODE (val) == NOP_EXPR
1737 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1738 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1740 #if 0 /* We never get such tree structure here. */
1741 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1742 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1743 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1744 /* Change in signedness doesn't matter
1745 if an enum value is unaffected. */
1748 /* If the value is extended from a narrower
1749 unsigned type, it doesn't matter whether we
1750 pass it as signed or unsigned; the value
1751 certainly is the same either way. */
1752 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1753 && TREE_UNSIGNED (TREE_TYPE (val)))
1755 else if (TREE_UNSIGNED (type))
1756 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1758 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1762 parmval = convert_for_assignment (type, val,
1763 (char *) 0, /* arg passing */
1764 fundecl, name, parmnum + 1);
1766 if (PROMOTE_PROTOTYPES
1767 && INTEGRAL_TYPE_P (type)
1768 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1769 parmval = default_conversion (parmval);
1771 result = tree_cons (NULL_TREE, parmval, result);
1773 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1774 && (TYPE_PRECISION (TREE_TYPE (val))
1775 < TYPE_PRECISION (double_type_node)))
1776 /* Convert `float' to `double'. */
1777 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1779 /* Convert `short' and `char' to full-size `int'. */
1780 result = tree_cons (NULL_TREE, default_conversion (val), result);
1783 typetail = TREE_CHAIN (typetail);
1786 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1789 error ("too few arguments to function `%s'",
1790 IDENTIFIER_POINTER (name));
1792 error ("too few arguments to function");
1795 return nreverse (result);
1798 /* This is the entry point used by the parser
1799 for binary operators in the input.
1800 In addition to constructing the expression,
1801 we check for operands that were written with other binary operators
1802 in a way that is likely to confuse the user. */
1805 parser_build_binary_op (code, arg1, arg2)
1806 enum tree_code code;
1809 tree result = build_binary_op (code, arg1, arg2, 1);
1812 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1813 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1814 enum tree_code code1 = ERROR_MARK;
1815 enum tree_code code2 = ERROR_MARK;
1817 if (class1 == 'e' || class1 == '1'
1818 || class1 == '2' || class1 == '<')
1819 code1 = C_EXP_ORIGINAL_CODE (arg1);
1820 if (class2 == 'e' || class2 == '1'
1821 || class2 == '2' || class2 == '<')
1822 code2 = C_EXP_ORIGINAL_CODE (arg2);
1824 /* Check for cases such as x+y<<z which users are likely
1825 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1826 is cleared to prevent these warnings. */
1827 if (warn_parentheses)
1829 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1831 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1832 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1833 warning ("suggest parentheses around + or - inside shift");
1836 if (code == TRUTH_ORIF_EXPR)
1838 if (code1 == TRUTH_ANDIF_EXPR
1839 || code2 == TRUTH_ANDIF_EXPR)
1840 warning ("suggest parentheses around && within ||");
1843 if (code == BIT_IOR_EXPR)
1845 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1846 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1847 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1848 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1849 warning ("suggest parentheses around arithmetic in operand of |");
1850 /* Check cases like x|y==z */
1851 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1852 warning ("suggest parentheses around comparison in operand of |");
1855 if (code == BIT_XOR_EXPR)
1857 if (code1 == BIT_AND_EXPR
1858 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1859 || code2 == BIT_AND_EXPR
1860 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1861 warning ("suggest parentheses around arithmetic in operand of ^");
1862 /* Check cases like x^y==z */
1863 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1864 warning ("suggest parentheses around comparison in operand of ^");
1867 if (code == BIT_AND_EXPR)
1869 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1870 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1871 warning ("suggest parentheses around + or - in operand of &");
1872 /* Check cases like x&y==z */
1873 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1874 warning ("suggest parentheses around comparison in operand of &");
1878 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1879 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1880 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1881 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1883 unsigned_conversion_warning (result, arg1);
1884 unsigned_conversion_warning (result, arg2);
1885 overflow_warning (result);
1887 class = TREE_CODE_CLASS (TREE_CODE (result));
1889 /* Record the code that was specified in the source,
1890 for the sake of warnings about confusing nesting. */
1891 if (class == 'e' || class == '1'
1892 || class == '2' || class == '<')
1893 C_SET_EXP_ORIGINAL_CODE (result, code);
1896 int flag = TREE_CONSTANT (result);
1897 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1898 so that convert_for_assignment wouldn't strip it.
1899 That way, we got warnings for things like p = (1 - 1).
1900 But it turns out we should not get those warnings. */
1901 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1902 C_SET_EXP_ORIGINAL_CODE (result, code);
1903 TREE_CONSTANT (result) = flag;
1909 /* Build a binary-operation expression without default conversions.
1910 CODE is the kind of expression to build.
1911 This function differs from `build' in several ways:
1912 the data type of the result is computed and recorded in it,
1913 warnings are generated if arg data types are invalid,
1914 special handling for addition and subtraction of pointers is known,
1915 and some optimization is done (operations on narrow ints
1916 are done in the narrower type when that gives the same result).
1917 Constant folding is also done before the result is returned.
1919 Note that the operands will never have enumeral types, or function
1920 or array types, because either they will have the default conversions
1921 performed or they have both just been converted to some other type in which
1922 the arithmetic is to be done. */
1925 build_binary_op (code, orig_op0, orig_op1, convert_p)
1926 enum tree_code code;
1927 tree orig_op0, orig_op1;
1931 register enum tree_code code0, code1;
1934 /* Expression code to give to the expression when it is built.
1935 Normally this is CODE, which is what the caller asked for,
1936 but in some special cases we change it. */
1937 register enum tree_code resultcode = code;
1939 /* Data type in which the computation is to be performed.
1940 In the simplest cases this is the common type of the arguments. */
1941 register tree result_type = NULL;
1943 /* Nonzero means operands have already been type-converted
1944 in whatever way is necessary.
1945 Zero means they need to be converted to RESULT_TYPE. */
1948 /* Nonzero means create the expression with this type, rather than
1950 tree build_type = 0;
1952 /* Nonzero means after finally constructing the expression
1953 convert it to this type. */
1954 tree final_type = 0;
1956 /* Nonzero if this is an operation like MIN or MAX which can
1957 safely be computed in short if both args are promoted shorts.
1958 Also implies COMMON.
1959 -1 indicates a bitwise operation; this makes a difference
1960 in the exact conditions for when it is safe to do the operation
1961 in a narrower mode. */
1964 /* Nonzero if this is a comparison operation;
1965 if both args are promoted shorts, compare the original shorts.
1966 Also implies COMMON. */
1967 int short_compare = 0;
1969 /* Nonzero if this is a right-shift operation, which can be computed on the
1970 original short and then promoted if the operand is a promoted short. */
1971 int short_shift = 0;
1973 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1978 op0 = default_conversion (orig_op0);
1979 op1 = default_conversion (orig_op1);
1987 type0 = TREE_TYPE (op0);
1988 type1 = TREE_TYPE (op1);
1990 /* The expression codes of the data types of the arguments tell us
1991 whether the arguments are integers, floating, pointers, etc. */
1992 code0 = TREE_CODE (type0);
1993 code1 = TREE_CODE (type1);
1995 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1996 STRIP_TYPE_NOPS (op0);
1997 STRIP_TYPE_NOPS (op1);
1999 /* If an error was already reported for one of the arguments,
2000 avoid reporting another error. */
2002 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2003 return error_mark_node;
2008 /* Handle the pointer + int case. */
2009 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2010 return pointer_int_sum (PLUS_EXPR, op0, op1);
2011 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2012 return pointer_int_sum (PLUS_EXPR, op1, op0);
2018 /* Subtraction of two similar pointers.
2019 We must subtract them as integers, then divide by object size. */
2020 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2021 && comp_target_types (type0, type1))
2022 return pointer_diff (op0, op1);
2023 /* Handle pointer minus int. Just like pointer plus int. */
2024 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2025 return pointer_int_sum (MINUS_EXPR, op0, op1);
2034 case TRUNC_DIV_EXPR:
2036 case FLOOR_DIV_EXPR:
2037 case ROUND_DIV_EXPR:
2038 case EXACT_DIV_EXPR:
2039 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2040 || code0 == COMPLEX_TYPE)
2041 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2042 || code1 == COMPLEX_TYPE))
2044 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2045 resultcode = RDIV_EXPR;
2047 /* Although it would be tempting to shorten always here, that
2048 loses on some targets, since the modulo instruction is
2049 undefined if the quotient can't be represented in the
2050 computation mode. We shorten only if unsigned or if
2051 dividing by something we know != -1. */
2052 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2053 || (TREE_CODE (op1) == INTEGER_CST
2054 && ! integer_all_onesp (op1)));
2060 case BIT_ANDTC_EXPR:
2063 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2065 /* If one operand is a constant, and the other is a short type
2066 that has been converted to an int,
2067 really do the work in the short type and then convert the
2068 result to int. If we are lucky, the constant will be 0 or 1
2069 in the short type, making the entire operation go away. */
2070 if (TREE_CODE (op0) == INTEGER_CST
2071 && TREE_CODE (op1) == NOP_EXPR
2072 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2073 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2075 final_type = result_type;
2076 op1 = TREE_OPERAND (op1, 0);
2077 result_type = TREE_TYPE (op1);
2079 if (TREE_CODE (op1) == INTEGER_CST
2080 && TREE_CODE (op0) == NOP_EXPR
2081 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2082 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2084 final_type = result_type;
2085 op0 = TREE_OPERAND (op0, 0);
2086 result_type = TREE_TYPE (op0);
2090 case TRUNC_MOD_EXPR:
2091 case FLOOR_MOD_EXPR:
2092 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2094 /* Although it would be tempting to shorten always here, that loses
2095 on some targets, since the modulo instruction is undefined if the
2096 quotient can't be represented in the computation mode. We shorten
2097 only if unsigned or if dividing by something we know != -1. */
2098 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2099 || (TREE_CODE (op1) == INTEGER_CST
2100 && ! integer_all_onesp (op1)));
2105 case TRUTH_ANDIF_EXPR:
2106 case TRUTH_ORIF_EXPR:
2107 case TRUTH_AND_EXPR:
2109 case TRUTH_XOR_EXPR:
2110 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2111 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2112 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2113 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2115 /* Result of these operations is always an int,
2116 but that does not mean the operands should be
2117 converted to ints! */
2118 result_type = integer_type_node;
2119 op0 = truthvalue_conversion (op0);
2120 op1 = truthvalue_conversion (op1);
2125 /* Shift operations: result has same type as first operand;
2126 always convert second operand to int.
2127 Also set SHORT_SHIFT if shifting rightward. */
2130 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2132 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2134 if (tree_int_cst_sgn (op1) < 0)
2135 warning ("right shift count is negative");
2138 if (! integer_zerop (op1))
2141 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2142 warning ("right shift count >= width of type");
2146 /* Use the type of the value to be shifted.
2147 This is what most traditional C compilers do. */
2148 result_type = type0;
2149 /* Unless traditional, convert the shift-count to an integer,
2150 regardless of size of value being shifted. */
2151 if (! flag_traditional)
2153 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2154 op1 = convert (integer_type_node, op1);
2155 /* Avoid converting op1 to result_type later. */
2162 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2164 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2166 if (tree_int_cst_sgn (op1) < 0)
2167 warning ("left shift count is negative");
2169 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2170 warning ("left shift count >= width of type");
2173 /* Use the type of the value to be shifted.
2174 This is what most traditional C compilers do. */
2175 result_type = type0;
2176 /* Unless traditional, convert the shift-count to an integer,
2177 regardless of size of value being shifted. */
2178 if (! flag_traditional)
2180 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2181 op1 = convert (integer_type_node, op1);
2182 /* Avoid converting op1 to result_type later. */
2190 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2192 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2194 if (tree_int_cst_sgn (op1) < 0)
2195 warning ("shift count is negative");
2196 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2197 warning ("shift count >= width of type");
2200 /* Use the type of the value to be shifted.
2201 This is what most traditional C compilers do. */
2202 result_type = type0;
2203 /* Unless traditional, convert the shift-count to an integer,
2204 regardless of size of value being shifted. */
2205 if (! flag_traditional)
2207 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2208 op1 = convert (integer_type_node, op1);
2209 /* Avoid converting op1 to result_type later. */
2217 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2218 warning ("comparing floating point with == or != is unsafe");
2219 /* Result of comparison is always int,
2220 but don't convert the args to int! */
2221 build_type = integer_type_node;
2222 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2223 || code0 == COMPLEX_TYPE)
2224 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2225 || code1 == COMPLEX_TYPE))
2227 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2229 register tree tt0 = TREE_TYPE (type0);
2230 register tree tt1 = TREE_TYPE (type1);
2231 /* Anything compares with void *. void * compares with anything.
2232 Otherwise, the targets must be compatible
2233 and both must be object or both incomplete. */
2234 if (comp_target_types (type0, type1))
2235 result_type = common_type (type0, type1);
2236 else if (VOID_TYPE_P (tt0))
2238 /* op0 != orig_op0 detects the case of something
2239 whose value is 0 but which isn't a valid null ptr const. */
2240 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2241 && TREE_CODE (tt1) == FUNCTION_TYPE)
2242 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2244 else if (VOID_TYPE_P (tt1))
2246 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2247 && TREE_CODE (tt0) == FUNCTION_TYPE)
2248 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2251 pedwarn ("comparison of distinct pointer types lacks a cast");
2253 if (result_type == NULL_TREE)
2254 result_type = ptr_type_node;
2256 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2257 && integer_zerop (op1))
2258 result_type = type0;
2259 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2260 && integer_zerop (op0))
2261 result_type = type1;
2262 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2264 result_type = type0;
2265 if (! flag_traditional)
2266 pedwarn ("comparison between pointer and integer");
2268 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2270 result_type = type1;
2271 if (! flag_traditional)
2272 pedwarn ("comparison between pointer and integer");
2278 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2279 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2281 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2283 if (comp_target_types (type0, type1))
2285 result_type = common_type (type0, type1);
2287 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2288 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2292 result_type = ptr_type_node;
2293 pedwarn ("comparison of distinct pointer types lacks a cast");
2302 build_type = integer_type_node;
2303 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2304 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2306 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2308 if (comp_target_types (type0, type1))
2310 result_type = common_type (type0, type1);
2311 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2312 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2313 pedwarn ("comparison of complete and incomplete pointers");
2315 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2316 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2320 result_type = ptr_type_node;
2321 pedwarn ("comparison of distinct pointer types lacks a cast");
2324 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2325 && integer_zerop (op1))
2327 result_type = type0;
2328 if (pedantic || extra_warnings)
2329 pedwarn ("ordered comparison of pointer with integer zero");
2331 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2332 && integer_zerop (op0))
2334 result_type = type1;
2336 pedwarn ("ordered comparison of pointer with integer zero");
2338 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2340 result_type = type0;
2341 if (! flag_traditional)
2342 pedwarn ("comparison between pointer and integer");
2344 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2346 result_type = type1;
2347 if (! flag_traditional)
2348 pedwarn ("comparison between pointer and integer");
2352 case UNORDERED_EXPR:
2359 build_type = integer_type_node;
2360 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2362 error ("unordered comparison on non-floating point argument");
2363 return error_mark_node;
2372 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2374 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2376 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2378 if (shorten || common || short_compare)
2379 result_type = common_type (type0, type1);
2381 /* For certain operations (which identify themselves by shorten != 0)
2382 if both args were extended from the same smaller type,
2383 do the arithmetic in that type and then extend.
2385 shorten !=0 and !=1 indicates a bitwise operation.
2386 For them, this optimization is safe only if
2387 both args are zero-extended or both are sign-extended.
2388 Otherwise, we might change the result.
2389 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2390 but calculated in (unsigned short) it would be (unsigned short)-1. */
2392 if (shorten && none_complex)
2394 int unsigned0, unsigned1;
2395 tree arg0 = get_narrower (op0, &unsigned0);
2396 tree arg1 = get_narrower (op1, &unsigned1);
2397 /* UNS is 1 if the operation to be done is an unsigned one. */
2398 int uns = TREE_UNSIGNED (result_type);
2401 final_type = result_type;
2403 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2404 but it *requires* conversion to FINAL_TYPE. */
2406 if ((TYPE_PRECISION (TREE_TYPE (op0))
2407 == TYPE_PRECISION (TREE_TYPE (arg0)))
2408 && TREE_TYPE (op0) != final_type)
2409 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2410 if ((TYPE_PRECISION (TREE_TYPE (op1))
2411 == TYPE_PRECISION (TREE_TYPE (arg1)))
2412 && TREE_TYPE (op1) != final_type)
2413 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2415 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2417 /* For bitwise operations, signedness of nominal type
2418 does not matter. Consider only how operands were extended. */
2422 /* Note that in all three cases below we refrain from optimizing
2423 an unsigned operation on sign-extended args.
2424 That would not be valid. */
2426 /* Both args variable: if both extended in same way
2427 from same width, do it in that width.
2428 Do it unsigned if args were zero-extended. */
2429 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2430 < TYPE_PRECISION (result_type))
2431 && (TYPE_PRECISION (TREE_TYPE (arg1))
2432 == TYPE_PRECISION (TREE_TYPE (arg0)))
2433 && unsigned0 == unsigned1
2434 && (unsigned0 || !uns))
2436 = signed_or_unsigned_type (unsigned0,
2437 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2438 else if (TREE_CODE (arg0) == INTEGER_CST
2439 && (unsigned1 || !uns)
2440 && (TYPE_PRECISION (TREE_TYPE (arg1))
2441 < TYPE_PRECISION (result_type))
2442 && (type = signed_or_unsigned_type (unsigned1,
2444 int_fits_type_p (arg0, type)))
2446 else if (TREE_CODE (arg1) == INTEGER_CST
2447 && (unsigned0 || !uns)
2448 && (TYPE_PRECISION (TREE_TYPE (arg0))
2449 < TYPE_PRECISION (result_type))
2450 && (type = signed_or_unsigned_type (unsigned0,
2452 int_fits_type_p (arg1, type)))
2456 /* Shifts can be shortened if shifting right. */
2461 tree arg0 = get_narrower (op0, &unsigned_arg);
2463 final_type = result_type;
2465 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2466 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2468 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2469 /* We can shorten only if the shift count is less than the
2470 number of bits in the smaller type size. */
2471 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2472 /* We cannot drop an unsigned shift after sign-extension. */
2473 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2475 /* Do an unsigned shift if the operand was zero-extended. */
2477 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
2478 /* Convert value-to-be-shifted to that type. */
2479 if (TREE_TYPE (op0) != result_type)
2480 op0 = convert (result_type, op0);
2485 /* Comparison operations are shortened too but differently.
2486 They identify themselves by setting short_compare = 1. */
2490 /* Don't write &op0, etc., because that would prevent op0
2491 from being kept in a register.
2492 Instead, make copies of the our local variables and
2493 pass the copies by reference, then copy them back afterward. */
2494 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2495 enum tree_code xresultcode = resultcode;
2497 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2502 op0 = xop0, op1 = xop1;
2504 resultcode = xresultcode;
2506 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2507 && skip_evaluation == 0)
2509 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2510 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2511 int unsignedp0, unsignedp1;
2512 tree primop0 = get_narrower (op0, &unsignedp0);
2513 tree primop1 = get_narrower (op1, &unsignedp1);
2517 STRIP_TYPE_NOPS (xop0);
2518 STRIP_TYPE_NOPS (xop1);
2520 /* Give warnings for comparisons between signed and unsigned
2521 quantities that may fail.
2523 Do the checking based on the original operand trees, so that
2524 casts will be considered, but default promotions won't be.
2526 Do not warn if the comparison is being done in a signed type,
2527 since the signed type will only be chosen if it can represent
2528 all the values of the unsigned type. */
2529 if (! TREE_UNSIGNED (result_type))
2531 /* Do not warn if both operands are the same signedness. */
2532 else if (op0_signed == op1_signed)
2539 sop = xop0, uop = xop1;
2541 sop = xop1, uop = xop0;
2543 /* Do not warn if the signed quantity is an
2544 unsuffixed integer literal (or some static
2545 constant expression involving such literals or a
2546 conditional expression involving such literals)
2547 and it is non-negative. */
2548 if (tree_expr_nonnegative_p (sop))
2550 /* Do not warn if the comparison is an equality operation,
2551 the unsigned quantity is an integral constant, and it
2552 would fit in the result if the result were signed. */
2553 else if (TREE_CODE (uop) == INTEGER_CST
2554 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2555 && int_fits_type_p (uop, signed_type (result_type)))
2557 /* Do not warn if the unsigned quantity is an enumeration
2558 constant and its maximum value would fit in the result
2559 if the result were signed. */
2560 else if (TREE_CODE (uop) == INTEGER_CST
2561 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2562 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2563 signed_type (result_type)))
2566 warning ("comparison between signed and unsigned");
2569 /* Warn if two unsigned values are being compared in a size
2570 larger than their original size, and one (and only one) is the
2571 result of a `~' operator. This comparison will always fail.
2573 Also warn if one operand is a constant, and the constant
2574 does not have all bits set that are set in the ~ operand
2575 when it is extended. */
2577 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2578 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2580 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2581 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2584 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2587 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2590 HOST_WIDE_INT constant, mask;
2591 int unsignedp, bits;
2593 if (host_integerp (primop0, 0))
2596 unsignedp = unsignedp1;
2597 constant = tree_low_cst (primop0, 0);
2602 unsignedp = unsignedp0;
2603 constant = tree_low_cst (primop1, 0);
2606 bits = TYPE_PRECISION (TREE_TYPE (primop));
2607 if (bits < TYPE_PRECISION (result_type)
2608 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2610 mask = (~ (HOST_WIDE_INT) 0) << bits;
2611 if ((mask & constant) != mask)
2612 warning ("comparison of promoted ~unsigned with constant");
2615 else if (unsignedp0 && unsignedp1
2616 && (TYPE_PRECISION (TREE_TYPE (primop0))
2617 < TYPE_PRECISION (result_type))
2618 && (TYPE_PRECISION (TREE_TYPE (primop1))
2619 < TYPE_PRECISION (result_type)))
2620 warning ("comparison of promoted ~unsigned with unsigned");
2626 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2627 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2628 Then the expression will be built.
2629 It will be given type FINAL_TYPE if that is nonzero;
2630 otherwise, it will be given type RESULT_TYPE. */
2634 binary_op_error (code);
2635 return error_mark_node;
2640 if (TREE_TYPE (op0) != result_type)
2641 op0 = convert (result_type, op0);
2642 if (TREE_TYPE (op1) != result_type)
2643 op1 = convert (result_type, op1);
2646 if (build_type == NULL_TREE)
2647 build_type = result_type;
2650 register tree result = build (resultcode, build_type, op0, op1);
2651 register tree folded;
2653 folded = fold (result);
2654 if (folded == result)
2655 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2656 if (final_type != 0)
2657 return convert (final_type, folded);
2662 /* Return a tree for the sum or difference (RESULTCODE says which)
2663 of pointer PTROP and integer INTOP. */
2666 pointer_int_sum (resultcode, ptrop, intop)
2667 enum tree_code resultcode;
2668 register tree ptrop, intop;
2672 register tree result;
2673 register tree folded;
2675 /* The result is a pointer of the same type that is being added. */
2677 register tree result_type = TREE_TYPE (ptrop);
2679 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2681 if (pedantic || warn_pointer_arith)
2682 pedwarn ("pointer of type `void *' used in arithmetic");
2683 size_exp = integer_one_node;
2685 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2687 if (pedantic || warn_pointer_arith)
2688 pedwarn ("pointer to a function used in arithmetic");
2689 size_exp = integer_one_node;
2692 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2694 /* If what we are about to multiply by the size of the elements
2695 contains a constant term, apply distributive law
2696 and multiply that constant term separately.
2697 This helps produce common subexpressions. */
2699 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2700 && ! TREE_CONSTANT (intop)
2701 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2702 && TREE_CONSTANT (size_exp)
2703 /* If the constant comes from pointer subtraction,
2704 skip this optimization--it would cause an error. */
2705 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2706 /* If the constant is unsigned, and smaller than the pointer size,
2707 then we must skip this optimization. This is because it could cause
2708 an overflow error if the constant is negative but INTOP is not. */
2709 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2710 || (TYPE_PRECISION (TREE_TYPE (intop))
2711 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2713 enum tree_code subcode = resultcode;
2714 tree int_type = TREE_TYPE (intop);
2715 if (TREE_CODE (intop) == MINUS_EXPR)
2716 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2717 /* Convert both subexpression types to the type of intop,
2718 because weird cases involving pointer arithmetic
2719 can result in a sum or difference with different type args. */
2720 ptrop = build_binary_op (subcode, ptrop,
2721 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2722 intop = convert (int_type, TREE_OPERAND (intop, 0));
2725 /* Convert the integer argument to a type the same size as sizetype
2726 so the multiply won't overflow spuriously. */
2728 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2729 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2730 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2731 TREE_UNSIGNED (sizetype)), intop);
2733 /* Replace the integer argument with a suitable product by the object size.
2734 Do this multiplication as signed, then convert to the appropriate
2735 pointer type (actually unsigned integral). */
2737 intop = convert (result_type,
2738 build_binary_op (MULT_EXPR, intop,
2739 convert (TREE_TYPE (intop), size_exp), 1));
2741 /* Create the sum or difference. */
2743 result = build (resultcode, result_type, ptrop, intop);
2745 folded = fold (result);
2746 if (folded == result)
2747 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2751 /* Return a tree for the difference of pointers OP0 and OP1.
2752 The resulting tree has type int. */
2755 pointer_diff (op0, op1)
2756 register tree op0, op1;
2758 register tree result, folded;
2759 tree restype = ptrdiff_type_node;
2761 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2763 if (pedantic || warn_pointer_arith)
2765 if (TREE_CODE (target_type) == VOID_TYPE)
2766 pedwarn ("pointer of type `void *' used in subtraction");
2767 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2768 pedwarn ("pointer to a function used in subtraction");
2771 /* First do the subtraction as integers;
2772 then drop through to build the divide operator.
2773 Do not do default conversions on the minus operator
2774 in case restype is a short type. */
2776 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2777 convert (restype, op1), 0);
2778 /* This generates an error if op1 is pointer to incomplete type. */
2779 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
2780 error ("arithmetic on pointer to an incomplete type");
2782 /* This generates an error if op0 is pointer to incomplete type. */
2783 op1 = c_size_in_bytes (target_type);
2785 /* Divide by the size, in easiest possible way. */
2787 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2789 folded = fold (result);
2790 if (folded == result)
2791 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2795 /* Construct and perhaps optimize a tree representation
2796 for a unary operation. CODE, a tree_code, specifies the operation
2797 and XARG is the operand. NOCONVERT nonzero suppresses
2798 the default promotions (such as from short to int). */
2801 build_unary_op (code, xarg, noconvert)
2802 enum tree_code code;
2806 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2807 register tree arg = xarg;
2808 register tree argtype = 0;
2809 register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2812 if (typecode == ERROR_MARK)
2813 return error_mark_node;
2814 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2815 typecode = INTEGER_TYPE;
2820 /* This is used for unary plus, because a CONVERT_EXPR
2821 is enough to prevent anybody from looking inside for
2822 associativity, but won't generate any code. */
2823 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2824 || typecode == COMPLEX_TYPE))
2826 error ("wrong type argument to unary plus");
2827 return error_mark_node;
2829 else if (!noconvert)
2830 arg = default_conversion (arg);
2834 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2835 || typecode == COMPLEX_TYPE))
2837 error ("wrong type argument to unary minus");
2838 return error_mark_node;
2840 else if (!noconvert)
2841 arg = default_conversion (arg);
2845 if (typecode == COMPLEX_TYPE)
2849 pedwarn ("ISO C does not support `~' for complex conjugation");
2851 arg = default_conversion (arg);
2853 else if (typecode != INTEGER_TYPE)
2855 error ("wrong type argument to bit-complement");
2856 return error_mark_node;
2858 else if (!noconvert)
2859 arg = default_conversion (arg);
2863 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2864 || typecode == COMPLEX_TYPE))
2866 error ("wrong type argument to abs");
2867 return error_mark_node;
2869 else if (!noconvert)
2870 arg = default_conversion (arg);
2874 /* Conjugating a real value is a no-op, but allow it anyway. */
2875 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2876 || typecode == COMPLEX_TYPE))
2878 error ("wrong type argument to conjugation");
2879 return error_mark_node;
2881 else if (!noconvert)
2882 arg = default_conversion (arg);
2885 case TRUTH_NOT_EXPR:
2886 if (typecode != INTEGER_TYPE
2887 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2888 && typecode != COMPLEX_TYPE
2889 /* These will convert to a pointer. */
2890 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2892 error ("wrong type argument to unary exclamation mark");
2893 return error_mark_node;
2895 arg = truthvalue_conversion (arg);
2896 return invert_truthvalue (arg);
2902 if (TREE_CODE (arg) == COMPLEX_CST)
2903 return TREE_REALPART (arg);
2904 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2905 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2910 if (TREE_CODE (arg) == COMPLEX_CST)
2911 return TREE_IMAGPART (arg);
2912 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2913 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2915 return convert (TREE_TYPE (arg), integer_zero_node);
2917 case PREINCREMENT_EXPR:
2918 case POSTINCREMENT_EXPR:
2919 case PREDECREMENT_EXPR:
2920 case POSTDECREMENT_EXPR:
2921 /* Handle complex lvalues (when permitted)
2922 by reduction to simpler cases. */
2924 val = unary_complex_lvalue (code, arg);
2928 /* Increment or decrement the real part of the value,
2929 and don't change the imaginary part. */
2930 if (typecode == COMPLEX_TYPE)
2935 pedwarn ("ISO C does not support `++' and `--' on complex types");
2937 arg = stabilize_reference (arg);
2938 real = build_unary_op (REALPART_EXPR, arg, 1);
2939 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2940 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2941 build_unary_op (code, real, 1), imag);
2944 /* Report invalid types. */
2946 if (typecode != POINTER_TYPE
2947 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2949 error ("wrong type argument to %s",
2950 code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2951 ? "increment" : "decrement");
2952 return error_mark_node;
2957 tree result_type = TREE_TYPE (arg);
2959 arg = get_unwidened (arg, 0);
2960 argtype = TREE_TYPE (arg);
2962 /* Compute the increment. */
2964 if (typecode == POINTER_TYPE)
2966 /* If pointer target is an undefined struct,
2967 we just cannot know how to do the arithmetic. */
2968 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2969 error ("%s of pointer to unknown structure",
2970 code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2971 ? "increment" : "decrement");
2972 else if ((pedantic || warn_pointer_arith)
2973 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2974 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2975 pedwarn ("wrong type argument to %s",
2976 code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2977 ? "increment" : "decrement");
2978 inc = c_size_in_bytes (TREE_TYPE (result_type));
2981 inc = integer_one_node;
2983 inc = convert (argtype, inc);
2985 /* Handle incrementing a cast-expression. */
2988 switch (TREE_CODE (arg))
2993 case FIX_TRUNC_EXPR:
2994 case FIX_FLOOR_EXPR:
2995 case FIX_ROUND_EXPR:
2997 pedantic_lvalue_warning (CONVERT_EXPR);
2998 /* If the real type has the same machine representation
2999 as the type it is cast to, we can make better output
3000 by adding directly to the inside of the cast. */
3001 if ((TREE_CODE (TREE_TYPE (arg))
3002 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
3003 && (TYPE_MODE (TREE_TYPE (arg))
3004 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
3005 arg = TREE_OPERAND (arg, 0);
3008 tree incremented, modify, value;
3009 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3010 value = boolean_increment (code, arg);
3013 arg = stabilize_reference (arg);
3014 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3017 value = save_expr (arg);
3018 incremented = build (((code == PREINCREMENT_EXPR
3019 || code == POSTINCREMENT_EXPR)
3020 ? PLUS_EXPR : MINUS_EXPR),
3021 argtype, value, inc);
3022 TREE_SIDE_EFFECTS (incremented) = 1;
3023 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3024 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3026 TREE_USED (value) = 1;
3036 /* Complain about anything else that is not a true lvalue. */
3037 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3038 || code == POSTINCREMENT_EXPR)
3039 ? "invalid lvalue in increment"
3040 : "invalid lvalue in decrement")))
3041 return error_mark_node;
3043 /* Report a read-only lvalue. */
3044 if (TREE_READONLY (arg))
3045 readonly_warning (arg,
3046 ((code == PREINCREMENT_EXPR
3047 || code == POSTINCREMENT_EXPR)
3048 ? "increment" : "decrement"));
3050 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3051 val = boolean_increment (code, arg);
3053 val = build (code, TREE_TYPE (arg), arg, inc);
3054 TREE_SIDE_EFFECTS (val) = 1;
3055 val = convert (result_type, val);
3056 if (TREE_CODE (val) != code)
3057 TREE_NO_UNUSED_WARNING (val) = 1;
3062 /* Note that this operation never does default_conversion
3063 regardless of NOCONVERT. */
3065 /* Let &* cancel out to simplify resulting code. */
3066 if (TREE_CODE (arg) == INDIRECT_REF)
3068 /* Don't let this be an lvalue. */
3069 if (lvalue_p (TREE_OPERAND (arg, 0)))
3070 return non_lvalue (TREE_OPERAND (arg, 0));
3071 return TREE_OPERAND (arg, 0);
3074 /* For &x[y], return x+y */
3075 if (TREE_CODE (arg) == ARRAY_REF)
3077 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3078 return error_mark_node;
3079 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3080 TREE_OPERAND (arg, 1), 1);
3083 /* Handle complex lvalues (when permitted)
3084 by reduction to simpler cases. */
3085 val = unary_complex_lvalue (code, arg);
3089 #if 0 /* Turned off because inconsistent;
3090 float f; *&(int)f = 3.4 stores in int format
3091 whereas (int)f = 3.4 stores in float format. */
3092 /* Address of a cast is just a cast of the address
3093 of the operand of the cast. */
3094 switch (TREE_CODE (arg))
3099 case FIX_TRUNC_EXPR:
3100 case FIX_FLOOR_EXPR:
3101 case FIX_ROUND_EXPR:
3104 pedwarn ("ISO C forbids the address of a cast expression");
3105 return convert (build_pointer_type (TREE_TYPE (arg)),
3106 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3111 /* Allow the address of a constructor if all the elements
3113 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3115 /* Anything not already handled and not a true memory reference
3117 else if (typecode != FUNCTION_TYPE
3118 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3119 return error_mark_node;
3121 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3122 argtype = TREE_TYPE (arg);
3124 /* If the lvalue is const or volatile, merge that into the type
3125 to which the address will point. Note that you can't get a
3126 restricted pointer by taking the address of something, so we
3127 only have to deal with `const' and `volatile' here. */
3128 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3129 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3130 argtype = c_build_type_variant (argtype,
3131 TREE_READONLY (arg),
3132 TREE_THIS_VOLATILE (arg));
3134 argtype = build_pointer_type (argtype);
3136 if (mark_addressable (arg) == 0)
3137 return error_mark_node;
3142 if (TREE_CODE (arg) == COMPONENT_REF)
3144 tree field = TREE_OPERAND (arg, 1);
3146 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3148 if (DECL_C_BIT_FIELD (field))
3150 error ("attempt to take address of bit-field structure member `%s'",
3151 IDENTIFIER_POINTER (DECL_NAME (field)));
3152 return error_mark_node;
3155 addr = fold (build (PLUS_EXPR, argtype,
3156 convert (argtype, addr),
3157 convert (argtype, byte_position (field))));
3160 addr = build1 (code, argtype, arg);
3162 /* Address of a static or external variable or
3163 file-scope function counts as a constant. */
3165 && ! (TREE_CODE (arg) == FUNCTION_DECL
3166 && DECL_CONTEXT (arg) != 0))
3167 TREE_CONSTANT (addr) = 1;
3176 argtype = TREE_TYPE (arg);
3177 return fold (build1 (code, argtype, arg));
3181 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3182 convert ARG with the same conversions in the same order
3183 and return the result. */
3186 convert_sequence (conversions, arg)
3190 switch (TREE_CODE (conversions))
3195 case FIX_TRUNC_EXPR:
3196 case FIX_FLOOR_EXPR:
3197 case FIX_ROUND_EXPR:
3199 return convert (TREE_TYPE (conversions),
3200 convert_sequence (TREE_OPERAND (conversions, 0),
3209 /* Return nonzero if REF is an lvalue valid for this language.
3210 Lvalues can be assigned, unless their type has TYPE_READONLY.
3211 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3217 register enum tree_code code = TREE_CODE (ref);
3224 return lvalue_p (TREE_OPERAND (ref, 0));
3235 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3236 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3240 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3247 /* Return nonzero if REF is an lvalue valid for this language;
3248 otherwise, print an error message and return zero. */
3251 lvalue_or_else (ref, msgid)
3255 int win = lvalue_p (ref);
3258 error ("%s", msgid);
3263 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3264 for certain kinds of expressions which are not really lvalues
3265 but which we can accept as lvalues.
3267 If ARG is not a kind of expression we can handle, return zero. */
3270 unary_complex_lvalue (code, arg)
3271 enum tree_code code;
3274 /* Handle (a, b) used as an "lvalue". */
3275 if (TREE_CODE (arg) == COMPOUND_EXPR)
3277 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3279 /* If this returns a function type, it isn't really being used as
3280 an lvalue, so don't issue a warning about it. */
3281 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3282 pedantic_lvalue_warning (COMPOUND_EXPR);
3284 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3285 TREE_OPERAND (arg, 0), real_result);
3288 /* Handle (a ? b : c) used as an "lvalue". */
3289 if (TREE_CODE (arg) == COND_EXPR)
3291 pedantic_lvalue_warning (COND_EXPR);
3292 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3293 pedantic_lvalue_warning (COMPOUND_EXPR);
3295 return (build_conditional_expr
3296 (TREE_OPERAND (arg, 0),
3297 build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3298 build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3304 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3305 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3308 pedantic_lvalue_warning (code)
3309 enum tree_code code;
3315 pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3318 pedwarn ("ISO C forbids use of compound expressions as lvalues");
3321 pedwarn ("ISO C forbids use of cast expressions as lvalues");
3326 /* Warn about storing in something that is `const'. */
3329 readonly_warning (arg, msgid)
3333 if (TREE_CODE (arg) == COMPONENT_REF)
3335 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3336 readonly_warning (TREE_OPERAND (arg, 0), msgid);
3338 pedwarn ("%s of read-only member `%s'", _(msgid),
3339 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3341 else if (TREE_CODE (arg) == VAR_DECL)
3342 pedwarn ("%s of read-only variable `%s'", _(msgid),
3343 IDENTIFIER_POINTER (DECL_NAME (arg)));
3345 pedwarn ("%s of read-only location", _(msgid));
3348 /* Mark EXP saying that we need to be able to take the
3349 address of it; it should not be allocated in a register.
3350 Value is 1 if successful. */
3353 mark_addressable (exp)
3356 register tree x = exp;
3358 switch (TREE_CODE (x))
3361 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3363 error ("cannot take address of bitfield `%s'",
3364 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3368 /* ... fall through ... */
3374 x = TREE_OPERAND (x, 0);
3378 TREE_ADDRESSABLE (x) = 1;
3385 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3386 && DECL_NONLOCAL (x))
3388 if (TREE_PUBLIC (x))
3390 error ("global register variable `%s' used in nested function",
3391 IDENTIFIER_POINTER (DECL_NAME (x)));
3394 pedwarn ("register variable `%s' used in nested function",
3395 IDENTIFIER_POINTER (DECL_NAME (x)));
3397 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3399 if (TREE_PUBLIC (x))
3401 error ("address of global register variable `%s' requested",
3402 IDENTIFIER_POINTER (DECL_NAME (x)));
3406 /* If we are making this addressable due to its having
3407 volatile components, give a different error message. Also
3408 handle the case of an unnamed parameter by not trying
3409 to give the name. */
3411 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3413 error ("cannot put object with volatile field into register");
3417 pedwarn ("address of register variable `%s' requested",
3418 IDENTIFIER_POINTER (DECL_NAME (x)));
3420 put_var_into_stack (x);
3424 TREE_ADDRESSABLE (x) = 1;
3425 #if 0 /* poplevel deals with this now. */
3426 if (DECL_CONTEXT (x) == 0)
3427 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3435 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3438 build_conditional_expr (ifexp, op1, op2)
3439 tree ifexp, op1, op2;
3441 register tree type1;
3442 register tree type2;
3443 register enum tree_code code1;
3444 register enum tree_code code2;
3445 register tree result_type = NULL;
3446 tree orig_op1 = op1, orig_op2 = op2;
3448 ifexp = truthvalue_conversion (default_conversion (ifexp));
3450 #if 0 /* Produces wrong result if within sizeof. */
3451 /* Don't promote the operands separately if they promote
3452 the same way. Return the unpromoted type and let the combined
3453 value get promoted if necessary. */
3455 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3456 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3457 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3458 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3460 if (TREE_CODE (ifexp) == INTEGER_CST)
3461 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3463 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3467 /* Promote both alternatives. */
3469 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3470 op1 = default_conversion (op1);
3471 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3472 op2 = default_conversion (op2);
3474 if (TREE_CODE (ifexp) == ERROR_MARK
3475 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3476 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3477 return error_mark_node;
3479 type1 = TREE_TYPE (op1);
3480 code1 = TREE_CODE (type1);
3481 type2 = TREE_TYPE (op2);
3482 code2 = TREE_CODE (type2);
3484 /* Quickly detect the usual case where op1 and op2 have the same type
3486 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3489 result_type = type1;
3491 result_type = TYPE_MAIN_VARIANT (type1);
3493 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3494 || code1 == COMPLEX_TYPE)
3495 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3496 || code2 == COMPLEX_TYPE))
3498 result_type = common_type (type1, type2);
3500 /* If -Wsign-compare, warn here if type1 and type2 have
3501 different signedness. We'll promote the signed to unsigned
3502 and later code won't know it used to be different.
3503 Do this check on the original types, so that explicit casts
3504 will be considered, but default promotions won't. */
3505 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3506 && !skip_evaluation)
3508 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3509 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3511 if (unsigned_op1 ^ unsigned_op2)
3513 /* Do not warn if the result type is signed, since the
3514 signed type will only be chosen if it can represent
3515 all the values of the unsigned type. */
3516 if (! TREE_UNSIGNED (result_type))
3518 /* Do not warn if the signed quantity is an unsuffixed
3519 integer literal (or some static constant expression
3520 involving such literals) and it is non-negative. */
3521 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3522 || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3525 warning ("signed and unsigned type in conditional expression");
3529 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3531 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3532 pedwarn ("ISO C forbids conditional expr with only one void side");
3533 result_type = void_type_node;
3535 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3537 if (comp_target_types (type1, type2))
3538 result_type = common_type (type1, type2);
3539 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3540 && TREE_CODE (orig_op1) != NOP_EXPR)
3541 result_type = qualify_type (type2, type1);
3542 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3543 && TREE_CODE (orig_op2) != NOP_EXPR)
3544 result_type = qualify_type (type1, type2);
3545 else if (VOID_TYPE_P (TREE_TYPE (type1)))
3547 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3548 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3549 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3550 TREE_TYPE (type2)));
3552 else if (VOID_TYPE_P (TREE_TYPE (type2)))
3554 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3555 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3556 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3557 TREE_TYPE (type1)));
3561 pedwarn ("pointer type mismatch in conditional expression");
3562 result_type = build_pointer_type (void_type_node);
3565 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3567 if (! integer_zerop (op2))
3568 pedwarn ("pointer/integer type mismatch in conditional expression");
3571 op2 = null_pointer_node;
3573 result_type = type1;
3575 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3577 if (!integer_zerop (op1))
3578 pedwarn ("pointer/integer type mismatch in conditional expression");
3581 op1 = null_pointer_node;
3583 result_type = type2;
3588 if (flag_cond_mismatch)
3589 result_type = void_type_node;
3592 error ("type mismatch in conditional expression");
3593 return error_mark_node;
3597 /* Merge const and volatile flags of the incoming types. */
3599 = build_type_variant (result_type,
3600 TREE_READONLY (op1) || TREE_READONLY (op2),
3601 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3603 if (result_type != TREE_TYPE (op1))
3604 op1 = convert_and_check (result_type, op1);
3605 if (result_type != TREE_TYPE (op2))
3606 op2 = convert_and_check (result_type, op2);
3608 if (TREE_CODE (ifexp) == INTEGER_CST)
3609 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3611 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3614 /* Given a list of expressions, return a compound expression
3615 that performs them all and returns the value of the last of them. */
3618 build_compound_expr (list)
3621 return internal_build_compound_expr (list, TRUE);
3625 internal_build_compound_expr (list, first_p)
3631 if (TREE_CHAIN (list) == 0)
3633 /* Convert arrays to pointers when there really is a comma operator. */
3634 if (!first_p && TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
3635 TREE_VALUE (list) = default_conversion (TREE_VALUE (list));
3637 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3638 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3640 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3641 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3642 list = TREE_OPERAND (list, 0);
3645 /* Don't let (0, 0) be null pointer constant. */
3646 if (!first_p && integer_zerop (TREE_VALUE (list)))
3647 return non_lvalue (TREE_VALUE (list));
3648 return TREE_VALUE (list);
3651 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3653 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3655 /* The left-hand operand of a comma expression is like an expression
3656 statement: with -W or -Wunused, we should warn if it doesn't have
3657 any side-effects, unless it was explicitly cast to (void). */
3658 if ((extra_warnings || warn_unused_value)
3659 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3660 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3661 warning ("left-hand operand of comma expression has no effect");
3663 /* When pedantic, a compound expression can be neither an lvalue
3664 nor an integer constant expression. */
3669 /* With -Wunused, we should also warn if the left-hand operand does have
3670 side-effects, but computes a value which is not used. For example, in
3671 `foo() + bar(), baz()' the result of the `+' operator is not used,
3672 so we should issue a warning. */
3673 else if (warn_unused_value)
3674 warn_if_unused_value (TREE_VALUE (list));
3676 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3679 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3682 build_c_cast (type, expr)
3686 register tree value = expr;
3688 if (type == error_mark_node || expr == error_mark_node)
3689 return error_mark_node;
3690 type = TYPE_MAIN_VARIANT (type);
3693 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3694 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3695 value = TREE_OPERAND (value, 0);
3698 if (TREE_CODE (type) == ARRAY_TYPE)
3700 error ("cast specifies array type");
3701 return error_mark_node;
3704 if (TREE_CODE (type) == FUNCTION_TYPE)
3706 error ("cast specifies function type");
3707 return error_mark_node;
3710 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3714 if (TREE_CODE (type) == RECORD_TYPE
3715 || TREE_CODE (type) == UNION_TYPE)
3716 pedwarn ("ISO C forbids casting nonscalar to the same type");
3719 else if (TREE_CODE (type) == UNION_TYPE)
3722 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3723 || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3724 value = default_conversion (value);
3726 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3727 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3728 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3737 pedwarn ("ISO C forbids casts to union type");
3738 if (TYPE_NAME (type) != 0)
3740 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3741 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3743 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3747 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3748 build_tree_list (field, value)),
3750 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3753 error ("cast to union type from type not present in union");
3754 return error_mark_node;
3760 /* If casting to void, avoid the error that would come
3761 from default_conversion in the case of a non-lvalue array. */
3762 if (type == void_type_node)
3763 return build1 (CONVERT_EXPR, type, value);
3765 /* Convert functions and arrays to pointers,
3766 but don't convert any other types. */
3767 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3768 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3769 value = default_conversion (value);
3770 otype = TREE_TYPE (value);
3772 /* Optionally warn about potentially worrisome casts. */
3775 && TREE_CODE (type) == POINTER_TYPE
3776 && TREE_CODE (otype) == POINTER_TYPE)
3778 tree in_type = type;
3779 tree in_otype = otype;
3782 /* Check that the qualifiers on IN_TYPE are a superset of
3783 the qualifiers of IN_OTYPE. The outermost level of
3784 POINTER_TYPE nodes is uninteresting and we stop as soon
3785 as we hit a non-POINTER_TYPE node on either type. */
3788 in_otype = TREE_TYPE (in_otype);
3789 in_type = TREE_TYPE (in_type);
3790 warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3792 while (TREE_CODE (in_type) == POINTER_TYPE
3793 && TREE_CODE (in_otype) == POINTER_TYPE);
3796 /* There are qualifiers present in IN_OTYPE that are not
3797 present in IN_TYPE. */
3798 warning ("cast discards qualifiers from pointer target type");
3801 /* Warn about possible alignment problems. */
3802 if (STRICT_ALIGNMENT && warn_cast_align
3803 && TREE_CODE (type) == POINTER_TYPE
3804 && TREE_CODE (otype) == POINTER_TYPE
3805 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3806 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3807 /* Don't warn about opaque types, where the actual alignment
3808 restriction is unknown. */
3809 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3810 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3811 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3812 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3813 warning ("cast increases required alignment of target type");
3815 if (TREE_CODE (type) == INTEGER_TYPE
3816 && TREE_CODE (otype) == POINTER_TYPE
3817 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3818 && !TREE_CONSTANT (value))
3819 warning ("cast from pointer to integer of different size");
3821 if (warn_bad_function_cast
3822 && TREE_CODE (value) == CALL_EXPR
3823 && TREE_CODE (type) != TREE_CODE (otype))
3824 warning ("cast does not match function type");
3826 if (TREE_CODE (type) == POINTER_TYPE
3827 && TREE_CODE (otype) == INTEGER_TYPE
3828 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3829 /* Don't warn about converting any constant. */
3830 && !TREE_CONSTANT (value))
3831 warning ("cast to pointer from integer of different size");
3834 value = convert (type, value);
3836 /* Ignore any integer overflow caused by the cast. */
3837 if (TREE_CODE (value) == INTEGER_CST)
3839 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3840 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3844 /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant. */
3845 if (pedantic && TREE_CODE (value) == INTEGER_CST
3846 && TREE_CODE (expr) == INTEGER_CST
3847 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3848 value = non_lvalue (value);
3850 /* If pedantic, don't let a cast be an lvalue. */
3851 if (value == expr && pedantic)
3852 value = non_lvalue (value);
3857 /* Interpret a cast of expression EXPR to type TYPE. */
3859 c_cast_expr (type, expr)
3862 int saved_wsp = warn_strict_prototypes;
3864 /* This avoids warnings about unprototyped casts on
3865 integers. E.g. "#define SIG_DFL (void(*)())0". */
3866 if (TREE_CODE (expr) == INTEGER_CST)
3867 warn_strict_prototypes = 0;
3868 type = groktypename (type);
3869 warn_strict_prototypes = saved_wsp;
3871 return build_c_cast (type, expr);
3875 /* Build an assignment expression of lvalue LHS from value RHS.
3876 MODIFYCODE is the code for a binary operator that we use
3877 to combine the old value of LHS with RHS to get the new value.
3878 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3881 build_modify_expr (lhs, modifycode, rhs)
3883 enum tree_code modifycode;
3885 register tree result;
3887 tree lhstype = TREE_TYPE (lhs);
3888 tree olhstype = lhstype;
3890 /* Types that aren't fully specified cannot be used in assignments. */
3891 lhs = require_complete_type (lhs);
3893 /* Avoid duplicate error messages from operands that had errors. */
3894 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3895 return error_mark_node;
3897 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3898 /* Do not use STRIP_NOPS here. We do not want an enumerator
3899 whose value is 0 to count as a null pointer constant. */
3900 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3901 rhs = TREE_OPERAND (rhs, 0);
3905 /* Handle control structure constructs used as "lvalues". */
3907 switch (TREE_CODE (lhs))
3909 /* Handle (a, b) used as an "lvalue". */
3911 pedantic_lvalue_warning (COMPOUND_EXPR);
3912 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3913 if (TREE_CODE (newrhs) == ERROR_MARK)
3914 return error_mark_node;
3915 return build (COMPOUND_EXPR, lhstype,
3916 TREE_OPERAND (lhs, 0), newrhs);
3918 /* Handle (a ? b : c) used as an "lvalue". */
3920 pedantic_lvalue_warning (COND_EXPR);
3921 rhs = save_expr (rhs);
3923 /* Produce (a ? (b = rhs) : (c = rhs))
3924 except that the RHS goes through a save-expr
3925 so the code to compute it is only emitted once. */
3927 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3928 build_modify_expr (TREE_OPERAND (lhs, 1),
3930 build_modify_expr (TREE_OPERAND (lhs, 2),
3932 if (TREE_CODE (cond) == ERROR_MARK)
3934 /* Make sure the code to compute the rhs comes out
3935 before the split. */
3936 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3937 /* But cast it to void to avoid an "unused" error. */
3938 convert (void_type_node, rhs), cond);
3944 /* If a binary op has been requested, combine the old LHS value with the RHS
3945 producing the value we should actually store into the LHS. */
3947 if (modifycode != NOP_EXPR)
3949 lhs = stabilize_reference (lhs);
3950 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3953 /* Handle a cast used as an "lvalue".
3954 We have already performed any binary operator using the value as cast.
3955 Now convert the result to the cast type of the lhs,
3956 and then true type of the lhs and store it there;
3957 then convert result back to the cast type to be the value
3958 of the assignment. */
3960 switch (TREE_CODE (lhs))
3965 case FIX_TRUNC_EXPR:
3966 case FIX_FLOOR_EXPR:
3967 case FIX_ROUND_EXPR:
3969 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3970 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3971 newrhs = default_conversion (newrhs);
3973 tree inner_lhs = TREE_OPERAND (lhs, 0);
3975 result = build_modify_expr (inner_lhs, NOP_EXPR,
3976 convert (TREE_TYPE (inner_lhs),
3977 convert (lhstype, newrhs)));
3978 if (TREE_CODE (result) == ERROR_MARK)
3980 pedantic_lvalue_warning (CONVERT_EXPR);
3981 return convert (TREE_TYPE (lhs), result);
3988 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3989 Reject anything strange now. */
3991 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3992 return error_mark_node;
3994 /* Warn about storing in something that is `const'. */
3996 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3997 || ((TREE_CODE (lhstype) == RECORD_TYPE
3998 || TREE_CODE (lhstype) == UNION_TYPE)
3999 && C_TYPE_FIELDS_READONLY (lhstype)))
4000 readonly_warning (lhs, "assignment");
4002 /* If storing into a structure or union member,
4003 it has probably been given type `int'.
4004 Compute the type that would go with
4005 the actual amount of storage the member occupies. */
4007 if (TREE_CODE (lhs) == COMPONENT_REF
4008 && (TREE_CODE (lhstype) == INTEGER_TYPE
4009 || TREE_CODE (lhstype) == BOOLEAN_TYPE
4010 || TREE_CODE (lhstype) == REAL_TYPE
4011 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4012 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4014 /* If storing in a field that is in actuality a short or narrower than one,
4015 we must store in the field in its actual type. */
4017 if (lhstype != TREE_TYPE (lhs))
4019 lhs = copy_node (lhs);
4020 TREE_TYPE (lhs) = lhstype;
4023 /* Convert new value to destination type. */
4025 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4026 NULL_TREE, NULL_TREE, 0);
4027 if (TREE_CODE (newrhs) == ERROR_MARK)
4028 return error_mark_node;
4032 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4033 TREE_SIDE_EFFECTS (result) = 1;
4035 /* If we got the LHS in a different type for storing in,
4036 convert the result back to the nominal type of LHS
4037 so that the value we return always has the same type
4038 as the LHS argument. */
4040 if (olhstype == TREE_TYPE (result))
4042 return convert_for_assignment (olhstype, result, _("assignment"),
4043 NULL_TREE, NULL_TREE, 0);
4046 /* Convert value RHS to type TYPE as preparation for an assignment
4047 to an lvalue of type TYPE.
4048 The real work of conversion is done by `convert'.
4049 The purpose of this function is to generate error messages
4050 for assignments that are not allowed in C.
4051 ERRTYPE is a string to use in error messages:
4052 "assignment", "return", etc. If it is null, this is parameter passing
4053 for a function call (and different error messages are output).
4055 FUNNAME is the name of the function being called,
4056 as an IDENTIFIER_NODE, or null.
4057 PARMNUM is the number of the argument, for printing in error messages. */
4060 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4062 const char *errtype;
4063 tree fundecl, funname;
4066 register enum tree_code codel = TREE_CODE (type);
4067 register tree rhstype;
4068 register enum tree_code coder;
4070 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4071 /* Do not use STRIP_NOPS here. We do not want an enumerator
4072 whose value is 0 to count as a null pointer constant. */
4073 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4074 rhs = TREE_OPERAND (rhs, 0);
4076 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4077 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4078 rhs = default_conversion (rhs);
4079 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4080 rhs = decl_constant_value_for_broken_optimization (rhs);
4082 rhstype = TREE_TYPE (rhs);
4083 coder = TREE_CODE (rhstype);
4085 if (coder == ERROR_MARK)
4086 return error_mark_node;
4088 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4090 overflow_warning (rhs);
4091 /* Check for Objective-C protocols. This will issue a warning if
4092 there are protocol violations. No need to use the return value. */
4093 maybe_objc_comptypes (type, rhstype, 0);
4097 if (coder == VOID_TYPE)
4099 error ("void value not ignored as it ought to be");
4100 return error_mark_node;
4102 /* A type converts to a reference to it.
4103 This code doesn't fully support references, it's just for the
4104 special case of va_start and va_copy. */
4105 if (codel == REFERENCE_TYPE
4106 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4108 if (mark_addressable (rhs) == 0)
4109 return error_mark_node;
4110 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4112 /* We already know that these two types are compatible, but they
4113 may not be exactly identical. In fact, `TREE_TYPE (type)' is
4114 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4115 likely to be va_list, a typedef to __builtin_va_list, which
4116 is different enough that it will cause problems later. */
4117 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4118 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4120 rhs = build1 (NOP_EXPR, type, rhs);
4123 /* Arithmetic types all interconvert, and enum is treated like int. */
4124 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4125 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4126 || codel == BOOLEAN_TYPE)
4127 && (coder == INTEGER_TYPE || coder == REAL_TYPE
4128 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4129 || coder == BOOLEAN_TYPE))
4130 return convert_and_check (type, rhs);
4132 /* Conversion to a transparent union from its member types.
4133 This applies only to function arguments. */
4134 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4137 tree marginal_memb_type = 0;
4139 for (memb_types = TYPE_FIELDS (type); memb_types;
4140 memb_types = TREE_CHAIN (memb_types))
4142 tree memb_type = TREE_TYPE (memb_types);
4144 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4145 TYPE_MAIN_VARIANT (rhstype)))
4148 if (TREE_CODE (memb_type) != POINTER_TYPE)
4151 if (coder == POINTER_TYPE)
4153 register tree ttl = TREE_TYPE (memb_type);
4154 register tree ttr = TREE_TYPE (rhstype);
4156 /* Any non-function converts to a [const][volatile] void *
4157 and vice versa; otherwise, targets must be the same.
4158 Meanwhile, the lhs target must have all the qualifiers of
4160 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4161 || comp_target_types (memb_type, rhstype))
4163 /* If this type won't generate any warnings, use it. */
4164 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4165 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4166 && TREE_CODE (ttl) == FUNCTION_TYPE)
4167 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4168 == TYPE_QUALS (ttr))
4169 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4170 == TYPE_QUALS (ttl))))
4173 /* Keep looking for a better type, but remember this one. */
4174 if (! marginal_memb_type)
4175 marginal_memb_type = memb_type;
4179 /* Can convert integer zero to any pointer type. */
4180 if (integer_zerop (rhs)
4181 || (TREE_CODE (rhs) == NOP_EXPR
4182 && integer_zerop (TREE_OPERAND (rhs, 0))))
4184 rhs = null_pointer_node;
4189 if (memb_types || marginal_memb_type)
4193 /* We have only a marginally acceptable member type;
4194 it needs a warning. */
4195 register tree ttl = TREE_TYPE (marginal_memb_type);
4196 register tree ttr = TREE_TYPE (rhstype);
4198 /* Const and volatile mean something different for function
4199 types, so the usual warnings are not appropriate. */
4200 if (TREE_CODE (ttr) == FUNCTION_TYPE
4201 && TREE_CODE (ttl) == FUNCTION_TYPE)
4203 /* Because const and volatile on functions are
4204 restrictions that say the function will not do
4205 certain things, it is okay to use a const or volatile
4206 function where an ordinary one is wanted, but not
4208 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4209 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4210 errtype, funname, parmnum);
4212 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4213 warn_for_assignment ("%s discards qualifiers from pointer target type",
4218 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4219 pedwarn ("ISO C prohibits argument conversion to union type");
4221 return build1 (NOP_EXPR, type, rhs);
4225 /* Conversions among pointers */
4226 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4227 && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4229 register tree ttl = TREE_TYPE (type);
4230 register tree ttr = TREE_TYPE (rhstype);
4232 /* Any non-function converts to a [const][volatile] void *
4233 and vice versa; otherwise, targets must be the same.
4234 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4235 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4236 || comp_target_types (type, rhstype)
4237 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4238 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4241 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4244 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4245 which are not ANSI null ptr constants. */
4246 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4247 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4248 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4249 errtype, funname, parmnum);
4250 /* Const and volatile mean something different for function types,
4251 so the usual warnings are not appropriate. */
4252 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4253 && TREE_CODE (ttl) != FUNCTION_TYPE)
4255 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4256 warn_for_assignment ("%s discards qualifiers from pointer target type",
4257 errtype, funname, parmnum);
4258 /* If this is not a case of ignoring a mismatch in signedness,
4260 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4261 || comp_target_types (type, rhstype))
4263 /* If there is a mismatch, do warn. */
4265 warn_for_assignment ("pointer targets in %s differ in signedness",
4266 errtype, funname, parmnum);
4268 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4269 && TREE_CODE (ttr) == FUNCTION_TYPE)
4271 /* Because const and volatile on functions are restrictions
4272 that say the function will not do certain things,
4273 it is okay to use a const or volatile function
4274 where an ordinary one is wanted, but not vice-versa. */
4275 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4276 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4277 errtype, funname, parmnum);
4281 warn_for_assignment ("%s from incompatible pointer type",
4282 errtype, funname, parmnum);
4283 return convert (type, rhs);
4285 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4287 /* An explicit constant 0 can convert to a pointer,
4288 or one that results from arithmetic, even including
4289 a cast to integer type. */
4290 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4292 ! (TREE_CODE (rhs) == NOP_EXPR
4293 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4294 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4295 && integer_zerop (TREE_OPERAND (rhs, 0))))
4297 warn_for_assignment ("%s makes pointer from integer without a cast",
4298 errtype, funname, parmnum);
4299 return convert (type, rhs);
4301 return null_pointer_node;
4303 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4305 warn_for_assignment ("%s makes integer from pointer without a cast",
4306 errtype, funname, parmnum);
4307 return convert (type, rhs);
4309 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4310 return convert (type, rhs);
4316 tree selector = maybe_building_objc_message_expr ();
4318 if (selector && parmnum > 2)
4319 error ("incompatible type for argument %d of `%s'",
4320 parmnum - 2, IDENTIFIER_POINTER (selector));
4322 error ("incompatible type for argument %d of `%s'",
4323 parmnum, IDENTIFIER_POINTER (funname));
4326 error ("incompatible type for argument %d of indirect function call",
4330 error ("incompatible types in %s", errtype);
4332 return error_mark_node;
4335 /* Print a warning using MSGID.
4336 It gets OPNAME as its one parameter.
4337 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4338 FUNCTION and ARGNUM are handled specially if we are building an
4339 Objective-C selector. */
4342 warn_for_assignment (msgid, opname, function, argnum)
4350 tree selector = maybe_building_objc_message_expr ();
4353 if (selector && argnum > 2)
4355 function = selector;
4360 /* Function name is known; supply it. */
4361 const char *argstring = _("passing arg %d of `%s'");
4362 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4363 + strlen (argstring) + 1 + 25
4365 sprintf (new_opname, argstring, argnum,
4366 IDENTIFIER_POINTER (function));
4370 /* Function name unknown (call through ptr); just give arg number.*/
4371 const char *argnofun = _("passing arg %d of pointer to function");
4372 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4373 sprintf (new_opname, argnofun, argnum);
4375 opname = new_opname;
4377 pedwarn (msgid, opname);
4380 /* If VALUE is a compound expr all of whose expressions are constant, then
4381 return its value. Otherwise, return error_mark_node.
4383 This is for handling COMPOUND_EXPRs as initializer elements
4384 which is allowed with a warning when -pedantic is specified. */
4387 valid_compound_expr_initializer (value, endtype)
4391 if (TREE_CODE (value) == COMPOUND_EXPR)
4393 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4395 return error_mark_node;
4396 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4399 else if (! TREE_CONSTANT (value)
4400 && ! initializer_constant_valid_p (value, endtype))
4401 return error_mark_node;
4406 /* Perform appropriate conversions on the initial value of a variable,
4407 store it in the declaration DECL,
4408 and print any error messages that are appropriate.
4409 If the init is invalid, store an ERROR_MARK. */
4412 store_init_value (decl, init)
4415 register tree value, type;
4417 /* If variable's type was invalidly declared, just ignore it. */
4419 type = TREE_TYPE (decl);
4420 if (TREE_CODE (type) == ERROR_MARK)
4423 /* Digest the specified initializer into an expression. */
4425 value = digest_init (type, init, TREE_STATIC (decl),
4426 TREE_STATIC (decl) || (pedantic && !flag_isoc99));
4428 /* Store the expression if valid; else report error. */
4431 /* Note that this is the only place we can detect the error
4432 in a case such as struct foo bar = (struct foo) { x, y };
4433 where there is one initial value which is a constructor expression. */
4434 if (value == error_mark_node)
4436 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4438 error ("initializer for static variable is not constant");
4439 value = error_mark_node;
4441 else if (TREE_STATIC (decl)
4442 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4444 error ("initializer for static variable uses complicated arithmetic");
4445 value = error_mark_node;
4449 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4451 if (! TREE_CONSTANT (value))
4452 pedwarn ("aggregate initializer is not constant");
4453 else if (! TREE_STATIC (value))
4454 pedwarn ("aggregate initializer uses complicated arithmetic");
4459 if (warn_traditional && !in_system_header
4460 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4461 warning ("traditional C rejects automatic aggregate initialization");
4463 DECL_INITIAL (decl) = value;
4465 /* ANSI wants warnings about out-of-range constant initializers. */
4466 STRIP_TYPE_NOPS (value);
4467 constant_expression_warning (value);
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)
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. */
4568 register int size = 0;
4569 register struct spelling *p;
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)
4586 register char *buffer;
4588 register char *d = buffer;
4589 register struct spelling *p;
4591 for (p = spelling_base; p < spelling; p++)
4592 if (p->kind == SPELLING_BOUNDS)
4594 sprintf (d, "[%d]", p->u.i);
4599 register const char *s;
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 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4720 /* Subtract 1 (or sizeof (wchar_t))
4721 because it's ok to ignore the terminating null char
4722 that is counted in the length of the constant. */
4723 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4724 TREE_STRING_LENGTH (inside_init)
4725 - ((TYPE_PRECISION (typ1)
4726 != TYPE_PRECISION (char_type_node))
4727 ? (TYPE_PRECISION (wchar_type_node)
4730 pedwarn_init ("initializer-string for array of chars is too long");
4736 /* Any type can be initialized
4737 from an expression of the same type, optionally with braces. */
4739 if (inside_init && TREE_TYPE (inside_init) != 0
4740 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4741 TYPE_MAIN_VARIANT (type))
4742 || (code == ARRAY_TYPE
4743 && comptypes (TREE_TYPE (inside_init), type))
4744 || (code == POINTER_TYPE
4745 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4746 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4747 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4748 TREE_TYPE (type)))))
4750 if (code == POINTER_TYPE
4751 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4752 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4753 inside_init = default_conversion (inside_init);
4754 else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4755 && TREE_CODE (inside_init) != CONSTRUCTOR)
4757 error_init ("array initialized from non-constant array expression");
4758 return error_mark_node;
4761 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4762 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4764 /* Compound expressions can only occur here if -pedantic or
4765 -pedantic-errors is specified. In the later case, we always want
4766 an error. In the former case, we simply want a warning. */
4767 if (require_constant && pedantic
4768 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4771 = valid_compound_expr_initializer (inside_init,
4772 TREE_TYPE (inside_init));
4773 if (inside_init == error_mark_node)
4774 error_init ("initializer element is not constant");
4776 pedwarn_init ("initializer element is not constant");
4777 if (flag_pedantic_errors)
4778 inside_init = error_mark_node;
4780 else if (require_constant
4781 && (!TREE_CONSTANT (inside_init)
4782 /* This test catches things like `7 / 0' which
4783 result in an expression for which TREE_CONSTANT
4784 is true, but which is not actually something
4785 that is a legal constant. We really should not
4786 be using this function, because it is a part of
4787 the back-end. Instead, the expression should
4788 already have been turned into ERROR_MARK_NODE. */
4789 || !initializer_constant_valid_p (inside_init,
4790 TREE_TYPE (inside_init))))
4792 error_init ("initializer element is not constant");
4793 inside_init = error_mark_node;
4799 /* Handle scalar types, including conversions. */
4801 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4802 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4804 /* Note that convert_for_assignment calls default_conversion
4805 for arrays and functions. We must not call it in the
4806 case where inside_init is a null pointer constant. */
4808 = convert_for_assignment (type, init, _("initialization"),
4809 NULL_TREE, NULL_TREE, 0);
4811 if (require_constant && ! TREE_CONSTANT (inside_init))
4813 error_init ("initializer element is not constant");
4814 inside_init = error_mark_node;
4816 else if (require_constant
4817 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4819 error_init ("initializer element is not computable at load time");
4820 inside_init = error_mark_node;
4826 /* Come here only for records and arrays. */
4828 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4830 error_init ("variable-sized object may not be initialized");
4831 return error_mark_node;
4834 /* Traditionally, you can write struct foo x = 0;
4835 and it initializes the first element of x to 0. */
4836 if (flag_traditional)
4838 tree top = 0, prev = 0, otype = type;
4839 while (TREE_CODE (type) == RECORD_TYPE
4840 || TREE_CODE (type) == ARRAY_TYPE
4841 || TREE_CODE (type) == QUAL_UNION_TYPE
4842 || TREE_CODE (type) == UNION_TYPE)
4844 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4848 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4850 if (TREE_CODE (type) == ARRAY_TYPE)
4851 type = TREE_TYPE (type);
4852 else if (TYPE_FIELDS (type))
4853 type = TREE_TYPE (TYPE_FIELDS (type));
4856 error_init ("invalid initializer");
4857 return error_mark_node;
4863 TREE_OPERAND (prev, 1)
4864 = build_tree_list (NULL_TREE,
4865 digest_init (type, init, require_constant,
4866 constructor_constant));
4870 return error_mark_node;
4872 error_init ("invalid initializer");
4873 return error_mark_node;
4876 /* Handle initializers that use braces. */
4878 /* Type of object we are accumulating a constructor for.
4879 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4880 static tree constructor_type;
4882 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4884 static tree constructor_fields;
4886 /* For an ARRAY_TYPE, this is the specified index
4887 at which to store the next element we get. */
4888 static tree constructor_index;
4890 /* For an ARRAY_TYPE, this is the maximum index. */
4891 static tree constructor_max_index;
4893 /* For a RECORD_TYPE, this is the first field not yet written out. */
4894 static tree constructor_unfilled_fields;
4896 /* For an ARRAY_TYPE, this is the index of the first element
4897 not yet written out. */
4898 static tree constructor_unfilled_index;
4900 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4901 This is so we can generate gaps between fields, when appropriate. */
4902 static tree constructor_bit_index;
4904 /* If we are saving up the elements rather than allocating them,
4905 this is the list of elements so far (in reverse order,
4906 most recent first). */
4907 static tree constructor_elements;
4909 /* 1 if constructor should be incrementally stored into a constructor chain,
4910 0 if all the elements should be kept in AVL tree. */
4911 static int constructor_incremental;
4913 /* 1 if so far this constructor's elements are all compile-time constants. */
4914 static int constructor_constant;
4916 /* 1 if so far this constructor's elements are all valid address constants. */
4917 static int constructor_simple;
4919 /* 1 if this constructor is erroneous so far. */
4920 static int constructor_erroneous;
4922 /* 1 if have called defer_addressed_constants. */
4923 static int constructor_subconstants_deferred;
4925 /* Structure for managing pending initializer elements, organized as an
4930 struct init_node *left, *right;
4931 struct init_node *parent;
4937 /* Tree of pending elements at this constructor level.
4938 These are elements encountered out of order
4939 which belong at places we haven't reached yet in actually
4941 Will never hold tree nodes across GC runs. */
4942 static struct init_node *constructor_pending_elts;
4944 /* The SPELLING_DEPTH of this constructor. */
4945 static int constructor_depth;
4947 /* 0 if implicitly pushing constructor levels is allowed. */
4948 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4950 static int require_constant_value;
4951 static int require_constant_elements;
4953 /* DECL node for which an initializer is being read.
4954 0 means we are reading a constructor expression
4955 such as (struct foo) {...}. */
4956 static tree constructor_decl;
4958 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4959 static const char *constructor_asmspec;
4961 /* Nonzero if this is an initializer for a top-level decl. */
4962 static int constructor_top_level;
4964 /* Nesting depth of designator list. */
4965 static int designator_depth;
4967 /* Nonzero if there were diagnosed errors in this designator list. */
4968 static int designator_errorneous;
4971 /* This stack has a level for each implicit or explicit level of
4972 structuring in the initializer, including the outermost one. It
4973 saves the values of most of the variables above. */
4975 struct constructor_range_stack;
4977 struct constructor_stack
4979 struct constructor_stack *next;
4984 tree unfilled_index;
4985 tree unfilled_fields;
4988 struct init_node *pending_elts;
4991 /* If nonzero, this value should replace the entire
4992 constructor at this level. */
4993 tree replacement_value;
4994 struct constructor_range_stack *range_stack;
5003 struct constructor_stack *constructor_stack;
5005 /* This stack represents designators from some range designator up to
5006 the last designator in the list. */
5008 struct constructor_range_stack
5010 struct constructor_range_stack *next, *prev;
5011 struct constructor_stack *stack;
5018 struct constructor_range_stack *constructor_range_stack;
5020 /* This stack records separate initializers that are nested.
5021 Nested initializers can't happen in ANSI C, but GNU C allows them
5022 in cases like { ... (struct foo) { ... } ... }. */
5024 struct initializer_stack
5026 struct initializer_stack *next;
5028 const char *asmspec;
5029 struct constructor_stack *constructor_stack;
5030 struct constructor_range_stack *constructor_range_stack;
5032 struct spelling *spelling;
5033 struct spelling *spelling_base;
5036 char require_constant_value;
5037 char require_constant_elements;
5041 struct initializer_stack *initializer_stack;
5043 /* Prepare to parse and output the initializer for variable DECL. */
5046 start_init (decl, asmspec_tree, top_level)
5052 struct initializer_stack *p
5053 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5054 const char *asmspec = 0;
5057 asmspec = TREE_STRING_POINTER (asmspec_tree);
5059 p->decl = constructor_decl;
5060 p->asmspec = constructor_asmspec;
5061 p->require_constant_value = require_constant_value;
5062 p->require_constant_elements = require_constant_elements;
5063 p->constructor_stack = constructor_stack;
5064 p->constructor_range_stack = constructor_range_stack;
5065 p->elements = constructor_elements;
5066 p->spelling = spelling;
5067 p->spelling_base = spelling_base;
5068 p->spelling_size = spelling_size;
5069 p->deferred = constructor_subconstants_deferred;
5070 p->top_level = constructor_top_level;
5071 p->next = initializer_stack;
5072 initializer_stack = p;
5074 constructor_decl = decl;
5075 constructor_asmspec = asmspec;
5076 constructor_subconstants_deferred = 0;
5077 constructor_top_level = top_level;
5081 require_constant_value = TREE_STATIC (decl);
5082 require_constant_elements
5083 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5084 /* For a scalar, you can always use any value to initialize,
5085 even within braces. */
5086 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5087 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5088 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5089 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5090 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5094 require_constant_value = 0;
5095 require_constant_elements = 0;
5096 locus = "(anonymous)";
5099 constructor_stack = 0;
5100 constructor_range_stack = 0;
5102 missing_braces_mentioned = 0;
5106 RESTORE_SPELLING_DEPTH (0);
5109 push_string (locus);
5115 struct initializer_stack *p = initializer_stack;
5117 /* Output subconstants (string constants, usually)
5118 that were referenced within this initializer and saved up.
5119 Must do this if and only if we called defer_addressed_constants. */
5120 if (constructor_subconstants_deferred)
5121 output_deferred_addressed_constants ();
5123 /* Free the whole constructor stack of this initializer. */
5124 while (constructor_stack)
5126 struct constructor_stack *q = constructor_stack;
5127 constructor_stack = q->next;
5131 if (constructor_range_stack)
5134 /* Pop back to the data of the outer initializer (if any). */
5135 constructor_decl = p->decl;
5136 constructor_asmspec = p->asmspec;
5137 require_constant_value = p->require_constant_value;
5138 require_constant_elements = p->require_constant_elements;
5139 constructor_stack = p->constructor_stack;
5140 constructor_range_stack = p->constructor_range_stack;
5141 constructor_elements = p->elements;
5142 spelling = p->spelling;
5143 spelling_base = p->spelling_base;
5144 spelling_size = p->spelling_size;
5145 constructor_subconstants_deferred = p->deferred;
5146 constructor_top_level = p->top_level;
5147 initializer_stack = p->next;
5151 /* Call here when we see the initializer is surrounded by braces.
5152 This is instead of a call to push_init_level;
5153 it is matched by a call to pop_init_level.
5155 TYPE is the type to initialize, for a constructor expression.
5156 For an initializer for a decl, TYPE is zero. */
5159 really_start_incremental_init (type)
5162 struct constructor_stack *p
5163 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5166 type = TREE_TYPE (constructor_decl);
5168 p->type = constructor_type;
5169 p->fields = constructor_fields;
5170 p->index = constructor_index;
5171 p->max_index = constructor_max_index;
5172 p->unfilled_index = constructor_unfilled_index;
5173 p->unfilled_fields = constructor_unfilled_fields;
5174 p->bit_index = constructor_bit_index;
5175 p->elements = constructor_elements;
5176 p->constant = constructor_constant;
5177 p->simple = constructor_simple;
5178 p->erroneous = constructor_erroneous;
5179 p->pending_elts = constructor_pending_elts;
5180 p->depth = constructor_depth;
5181 p->replacement_value = 0;
5185 p->incremental = constructor_incremental;
5187 constructor_stack = p;
5189 constructor_constant = 1;
5190 constructor_simple = 1;
5191 constructor_depth = SPELLING_DEPTH ();
5192 constructor_elements = 0;
5193 constructor_pending_elts = 0;
5194 constructor_type = type;
5195 constructor_incremental = 1;
5196 designator_depth = 0;
5197 designator_errorneous = 0;
5199 if (TREE_CODE (constructor_type) == RECORD_TYPE
5200 || TREE_CODE (constructor_type) == UNION_TYPE)
5202 constructor_fields = TYPE_FIELDS (constructor_type);
5203 /* Skip any nameless bit fields at the beginning. */
5204 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5205 && DECL_NAME (constructor_fields) == 0)
5206 constructor_fields = TREE_CHAIN (constructor_fields);
5208 constructor_unfilled_fields = constructor_fields;
5209 constructor_bit_index = bitsize_zero_node;
5211 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5213 if (TYPE_DOMAIN (constructor_type))
5215 constructor_max_index
5216 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5218 /* Detect non-empty initializations of zero-length arrays. */
5219 if (constructor_max_index == NULL_TREE)
5220 constructor_max_index = build_int_2 (-1, -1);
5223 = convert (bitsizetype,
5224 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5227 constructor_index = bitsize_zero_node;
5229 constructor_unfilled_index = constructor_index;
5233 /* Handle the case of int x = {5}; */
5234 constructor_fields = constructor_type;
5235 constructor_unfilled_fields = constructor_type;
5239 /* Push down into a subobject, for initialization.
5240 If this is for an explicit set of braces, IMPLICIT is 0.
5241 If it is because the next element belongs at a lower level,
5242 IMPLICIT is 1 (or 2 if the push is because of designator list). */
5245 push_init_level (implicit)
5248 struct constructor_stack *p;
5249 tree value = NULL_TREE;
5251 /* If we've exhausted any levels that didn't have braces,
5253 while (constructor_stack->implicit)
5255 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5256 || TREE_CODE (constructor_type) == UNION_TYPE)
5257 && constructor_fields == 0)
5258 process_init_element (pop_init_level (1));
5259 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5260 && tree_int_cst_lt (constructor_max_index, constructor_index))
5261 process_init_element (pop_init_level (1));
5266 /* Unless this is an explicit brace, we need to preserve previous
5270 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5271 || TREE_CODE (constructor_type) == UNION_TYPE)
5272 && constructor_fields)
5273 value = find_init_member (constructor_fields);
5274 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5275 value = find_init_member (constructor_index);
5278 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5279 p->type = constructor_type;
5280 p->fields = constructor_fields;
5281 p->index = constructor_index;
5282 p->max_index = constructor_max_index;
5283 p->unfilled_index = constructor_unfilled_index;
5284 p->unfilled_fields = constructor_unfilled_fields;
5285 p->bit_index = constructor_bit_index;
5286 p->elements = constructor_elements;
5287 p->constant = constructor_constant;
5288 p->simple = constructor_simple;
5289 p->erroneous = constructor_erroneous;
5290 p->pending_elts = constructor_pending_elts;
5291 p->depth = constructor_depth;
5292 p->replacement_value = 0;
5293 p->implicit = implicit;
5295 p->incremental = constructor_incremental;
5296 p->next = constructor_stack;
5298 constructor_stack = p;
5300 constructor_constant = 1;
5301 constructor_simple = 1;
5302 constructor_depth = SPELLING_DEPTH ();
5303 constructor_elements = 0;
5304 constructor_incremental = 1;
5305 constructor_pending_elts = 0;
5308 p->range_stack = constructor_range_stack;
5309 constructor_range_stack = 0;
5310 designator_depth = 0;
5311 designator_errorneous = 0;
5314 /* Don't die if an entire brace-pair level is superfluous
5315 in the containing level. */
5316 if (constructor_type == 0)
5318 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5319 || TREE_CODE (constructor_type) == UNION_TYPE)
5321 /* Don't die if there are extra init elts at the end. */
5322 if (constructor_fields == 0)
5323 constructor_type = 0;
5326 constructor_type = TREE_TYPE (constructor_fields);
5327 push_member_name (constructor_fields);
5328 constructor_depth++;
5331 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5333 constructor_type = TREE_TYPE (constructor_type);
5334 push_array_bounds (tree_low_cst (constructor_index, 0));
5335 constructor_depth++;
5338 if (constructor_type == 0)
5340 error_init ("extra brace group at end of initializer");
5341 constructor_fields = 0;
5342 constructor_unfilled_fields = 0;
5346 if (value && TREE_CODE (value) == CONSTRUCTOR)
5348 constructor_constant = TREE_CONSTANT (value);
5349 constructor_simple = TREE_STATIC (value);
5350 constructor_elements = TREE_OPERAND (value, 1);
5351 if (constructor_elements
5352 && (TREE_CODE (constructor_type) == RECORD_TYPE
5353 || TREE_CODE (constructor_type) == ARRAY_TYPE))
5354 set_nonincremental_init ();
5357 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5359 missing_braces_mentioned = 1;
5360 warning_init ("missing braces around initializer");
5363 if (TREE_CODE (constructor_type) == RECORD_TYPE
5364 || TREE_CODE (constructor_type) == UNION_TYPE)
5366 constructor_fields = TYPE_FIELDS (constructor_type);
5367 /* Skip any nameless bit fields at the beginning. */
5368 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5369 && DECL_NAME (constructor_fields) == 0)
5370 constructor_fields = TREE_CHAIN (constructor_fields);
5372 constructor_unfilled_fields = constructor_fields;
5373 constructor_bit_index = bitsize_zero_node;
5375 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5377 if (TYPE_DOMAIN (constructor_type))
5379 constructor_max_index
5380 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5382 = convert (bitsizetype,
5383 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5385 /* ??? For GCC 3.1, remove special case initialization of
5386 zero-length array members from pop_init_level and set
5387 constructor_max_index such that we get the normal
5388 "excess elements" warning. */
5391 constructor_index = bitsize_zero_node;
5393 constructor_unfilled_index = constructor_index;
5394 if (value && TREE_CODE (value) == STRING_CST)
5396 /* We need to split the char/wchar array into individual
5397 characters, so that we don't have to special case it
5399 set_nonincremental_init_from_string (value);
5404 warning_init ("braces around scalar initializer");
5405 constructor_fields = constructor_type;
5406 constructor_unfilled_fields = constructor_type;
5410 /* At the end of an implicit or explicit brace level,
5411 finish up that level of constructor.
5412 If we were outputting the elements as they are read, return 0
5413 from inner levels (process_init_element ignores that),
5414 but return error_mark_node from the outermost level
5415 (that's what we want to put in DECL_INITIAL).
5416 Otherwise, return a CONSTRUCTOR expression. */
5419 pop_init_level (implicit)
5422 struct constructor_stack *p;
5423 HOST_WIDE_INT size = 0;
5424 tree constructor = 0;
5428 /* When we come to an explicit close brace,
5429 pop any inner levels that didn't have explicit braces. */
5430 while (constructor_stack->implicit)
5431 process_init_element (pop_init_level (1));
5433 if (constructor_range_stack)
5437 p = constructor_stack;
5439 if (constructor_type != 0)
5440 size = int_size_in_bytes (constructor_type);
5442 /* Error for initializing a flexible array member, or a zero-length
5443 array member in an inappropriate context. */
5444 if (constructor_type && constructor_fields
5445 && TREE_CODE (constructor_type) == ARRAY_TYPE
5446 && TYPE_DOMAIN (constructor_type)
5447 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5449 /* Silently discard empty initializations. The parser will
5450 already have pedwarned for empty brackets. */
5451 if (integer_zerop (constructor_unfilled_index))
5452 constructor_type = NULL_TREE;
5453 else if (! TYPE_SIZE (constructor_type))
5455 if (constructor_depth > 2)
5456 error_init ("initialization of flexible array member in a nested context");
5458 pedwarn_init ("initialization of a flexible array member");
5460 /* We have already issued an error message for the existance
5461 of a flexible array member not at the end of the structure.
5462 Discard the initializer so that we do not abort later. */
5463 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5464 constructor_type = NULL_TREE;
5468 warning_init ("deprecated initialization of zero-length array");
5470 /* We must be initializing the last member of a top-level struct. */
5471 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5473 error_init ("initialization of zero-length array before end of structure");
5474 /* Discard the initializer so that we do not abort later. */
5475 constructor_type = NULL_TREE;
5477 else if (constructor_depth > 2)
5478 error_init ("initialization of zero-length array inside a nested context");
5482 /* Warn when some struct elements are implicitly initialized to zero. */
5485 && TREE_CODE (constructor_type) == RECORD_TYPE
5486 && constructor_unfilled_fields)
5488 /* Do not warn for flexible array members or zero-length arrays. */
5489 while (constructor_unfilled_fields
5490 && (! DECL_SIZE (constructor_unfilled_fields)
5491 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5492 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5494 if (constructor_unfilled_fields)
5496 push_member_name (constructor_unfilled_fields);
5497 warning_init ("missing initializer");
5498 RESTORE_SPELLING_DEPTH (constructor_depth);
5502 /* Now output all pending elements. */
5503 constructor_incremental = 1;
5504 output_pending_init_elements (1);
5506 /* Pad out the end of the structure. */
5507 if (p->replacement_value)
5508 /* If this closes a superfluous brace pair,
5509 just pass out the element between them. */
5510 constructor = p->replacement_value;
5511 else if (constructor_type == 0)
5513 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5514 && TREE_CODE (constructor_type) != UNION_TYPE
5515 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5517 /* A nonincremental scalar initializer--just return
5518 the element, after verifying there is just one. */
5519 if (constructor_elements == 0)
5521 if (!constructor_erroneous)
5522 error_init ("empty scalar initializer");
5523 constructor = error_mark_node;
5525 else if (TREE_CHAIN (constructor_elements) != 0)
5527 error_init ("extra elements in scalar initializer");
5528 constructor = TREE_VALUE (constructor_elements);
5531 constructor = TREE_VALUE (constructor_elements);
5535 if (constructor_erroneous)
5536 constructor = error_mark_node;
5539 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5540 nreverse (constructor_elements));
5541 if (constructor_constant)
5542 TREE_CONSTANT (constructor) = 1;
5543 if (constructor_constant && constructor_simple)
5544 TREE_STATIC (constructor) = 1;
5548 constructor_type = p->type;
5549 constructor_fields = p->fields;
5550 constructor_index = p->index;
5551 constructor_max_index = p->max_index;
5552 constructor_unfilled_index = p->unfilled_index;
5553 constructor_unfilled_fields = p->unfilled_fields;
5554 constructor_bit_index = p->bit_index;
5555 constructor_elements = p->elements;
5556 constructor_constant = p->constant;
5557 constructor_simple = p->simple;
5558 constructor_erroneous = p->erroneous;
5559 constructor_incremental = p->incremental;
5560 constructor_pending_elts = p->pending_elts;
5561 constructor_depth = p->depth;
5563 constructor_range_stack = p->range_stack;
5564 RESTORE_SPELLING_DEPTH (constructor_depth);
5566 constructor_stack = p->next;
5569 if (constructor == 0)
5571 if (constructor_stack == 0)
5572 return error_mark_node;
5578 /* Common handling for both array range and field name designators.
5579 ARRAY argument is non-zero for array ranges. Returns zero for success. */
5582 set_designator (array)
5586 enum tree_code subcode;
5588 /* Don't die if an entire brace-pair level is superfluous
5589 in the containing level. */
5590 if (constructor_type == 0)
5593 /* If there were errors in this designator list already, bail out silently. */
5594 if (designator_errorneous)
5597 if (!designator_depth)
5599 if (constructor_range_stack)
5602 /* Designator list starts at the level of closest explicit
5604 while (constructor_stack->implicit)
5605 process_init_element (pop_init_level (1));
5609 if (constructor_no_implicit)
5611 error_init ("initialization designators may not nest");
5615 if (TREE_CODE (constructor_type) == RECORD_TYPE
5616 || TREE_CODE (constructor_type) == UNION_TYPE)
5618 subtype = TREE_TYPE (constructor_fields);
5619 if (subtype != error_mark_node)
5620 subtype = TYPE_MAIN_VARIANT (subtype);
5622 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5624 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5629 subcode = TREE_CODE (subtype);
5630 if (array && subcode != ARRAY_TYPE)
5632 error_init ("array index in non-array initializer");
5635 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5637 error_init ("field name not in record or union initializer");
5641 push_init_level (2);
5645 /* If there are range designators in designator list, push a new designator
5646 to constructor_range_stack. RANGE_END is end of such stack range or
5647 NULL_TREE if there is no range designator at this level. */
5650 push_range_stack (range_end)
5653 struct constructor_range_stack *p;
5655 p = (struct constructor_range_stack *)
5656 ggc_alloc (sizeof (struct constructor_range_stack));
5657 p->prev = constructor_range_stack;
5659 p->fields = constructor_fields;
5660 p->range_start = constructor_index;
5661 p->index = constructor_index;
5662 p->stack = constructor_stack;
5663 p->range_end = range_end;
5664 if (constructor_range_stack)
5665 constructor_range_stack->next = p;
5666 constructor_range_stack = p;
5669 /* Within an array initializer, specify the next index to be initialized.
5670 FIRST is that index. If LAST is nonzero, then initialize a range
5671 of indices, running from FIRST through LAST. */
5674 set_init_index (first, last)
5677 if (set_designator (1))
5680 designator_errorneous = 1;
5682 while ((TREE_CODE (first) == NOP_EXPR
5683 || TREE_CODE (first) == CONVERT_EXPR
5684 || TREE_CODE (first) == NON_LVALUE_EXPR)
5685 && (TYPE_MODE (TREE_TYPE (first))
5686 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5687 first = TREE_OPERAND (first, 0);
5690 while ((TREE_CODE (last) == NOP_EXPR
5691 || TREE_CODE (last) == CONVERT_EXPR
5692 || TREE_CODE (last) == NON_LVALUE_EXPR)
5693 && (TYPE_MODE (TREE_TYPE (last))
5694 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5695 last = TREE_OPERAND (last, 0);
5697 if (TREE_CODE (first) != INTEGER_CST)
5698 error_init ("nonconstant array index in initializer");
5699 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5700 error_init ("nonconstant array index in initializer");
5701 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5702 error_init ("array index in non-array initializer");
5703 else if (constructor_max_index
5704 && tree_int_cst_lt (constructor_max_index, first))
5705 error_init ("array index in initializer exceeds array bounds");
5708 constructor_index = convert (bitsizetype, first);
5712 if (tree_int_cst_equal (first, last))
5714 else if (tree_int_cst_lt (last, first))
5716 error_init ("empty index range in initializer");
5721 last = convert (bitsizetype, last);
5722 if (constructor_max_index != 0
5723 && tree_int_cst_lt (constructor_max_index, last))
5725 error_init ("array index range in initializer exceeds array bounds");
5732 designator_errorneous = 0;
5733 if (constructor_range_stack || last)
5734 push_range_stack (last);
5738 /* Within a struct initializer, specify the next field to be initialized. */
5741 set_init_label (fieldname)
5746 if (set_designator (0))
5749 designator_errorneous = 1;
5751 if (TREE_CODE (constructor_type) != RECORD_TYPE
5752 && TREE_CODE (constructor_type) != UNION_TYPE)
5754 error_init ("field name not in record or union initializer");
5758 for (tail = TYPE_FIELDS (constructor_type); tail;
5759 tail = TREE_CHAIN (tail))
5761 if (DECL_NAME (tail) == fieldname)
5766 error ("unknown field `%s' specified in initializer",
5767 IDENTIFIER_POINTER (fieldname));
5770 constructor_fields = tail;
5772 designator_errorneous = 0;
5773 if (constructor_range_stack)
5774 push_range_stack (NULL_TREE);
5778 /* Add a new initializer to the tree of pending initializers. PURPOSE
5779 indentifies the initializer, either array index or field in a structure.
5780 VALUE is the value of that index or field. */
5783 add_pending_init (purpose, value)
5784 tree purpose, value;
5786 struct init_node *p, **q, *r;
5788 q = &constructor_pending_elts;
5791 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5796 if (tree_int_cst_lt (purpose, p->purpose))
5798 else if (tree_int_cst_lt (p->purpose, purpose))
5802 if (TREE_SIDE_EFFECTS (p->value))
5803 warning_init ("initialized field with side-effects overwritten");
5813 bitpos = bit_position (purpose);
5817 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5819 else if (p->purpose != purpose)
5823 if (TREE_SIDE_EFFECTS (p->value))
5824 warning_init ("initialized field with side-effects overwritten");
5831 r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5832 r->purpose = purpose;
5843 struct init_node *s;
5847 if (p->balance == 0)
5849 else if (p->balance < 0)
5856 p->left->parent = p;
5873 constructor_pending_elts = r;
5878 struct init_node *t = r->right;
5882 r->right->parent = r;
5887 p->left->parent = p;
5890 p->balance = t->balance < 0;
5891 r->balance = -(t->balance > 0);
5906 constructor_pending_elts = t;
5912 /* p->balance == +1; growth of left side balances the node. */
5917 else /* r == p->right */
5919 if (p->balance == 0)
5920 /* Growth propagation from right side. */
5922 else if (p->balance > 0)
5929 p->right->parent = p;
5946 constructor_pending_elts = r;
5948 else /* r->balance == -1 */
5951 struct init_node *t = r->left;
5955 r->left->parent = r;
5960 p->right->parent = p;
5963 r->balance = (t->balance < 0);
5964 p->balance = -(t->balance > 0);
5979 constructor_pending_elts = t;
5985 /* p->balance == -1; growth of right side balances the node. */
5996 /* Build AVL tree from a sorted chain. */
5999 set_nonincremental_init ()
6003 if (TREE_CODE (constructor_type) != RECORD_TYPE
6004 && TREE_CODE (constructor_type) != ARRAY_TYPE)
6007 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
6008 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
6009 constructor_elements = 0;
6010 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6012 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6013 /* Skip any nameless bit fields at the beginning. */
6014 while (constructor_unfilled_fields != 0
6015 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6016 && DECL_NAME (constructor_unfilled_fields) == 0)
6017 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6020 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6022 if (TYPE_DOMAIN (constructor_type))
6023 constructor_unfilled_index
6024 = convert (bitsizetype,
6025 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6027 constructor_unfilled_index = bitsize_zero_node;
6029 constructor_incremental = 0;
6032 /* Build AVL tree from a string constant. */
6035 set_nonincremental_init_from_string (str)
6038 tree value, purpose, type;
6039 HOST_WIDE_INT val[2];
6040 const char *p, *end;
6041 int byte, wchar_bytes, charwidth, bitpos;
6043 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6046 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6047 == TYPE_PRECISION (char_type_node))
6049 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6050 == TYPE_PRECISION (wchar_type_node))
6051 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6055 charwidth = TYPE_PRECISION (char_type_node);
6056 type = TREE_TYPE (constructor_type);
6057 p = TREE_STRING_POINTER (str);
6058 end = p + TREE_STRING_LENGTH (str);
6060 for (purpose = bitsize_zero_node;
6061 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6062 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6064 if (wchar_bytes == 1)
6066 val[1] = (unsigned char) *p++;
6073 for (byte = 0; byte < wchar_bytes; byte++)
6075 if (BYTES_BIG_ENDIAN)
6076 bitpos = (wchar_bytes - byte - 1) * charwidth;
6078 bitpos = byte * charwidth;
6079 val[bitpos < HOST_BITS_PER_WIDE_INT]
6080 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6081 << (bitpos % HOST_BITS_PER_WIDE_INT);
6085 if (!TREE_UNSIGNED (type))
6087 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6088 if (bitpos < HOST_BITS_PER_WIDE_INT)
6090 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6092 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6096 else if (bitpos == HOST_BITS_PER_WIDE_INT)
6101 else if (val[0] & (((HOST_WIDE_INT) 1)
6102 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6103 val[0] |= ((HOST_WIDE_INT) -1)
6104 << (bitpos - HOST_BITS_PER_WIDE_INT);
6107 value = build_int_2 (val[1], val[0]);
6108 TREE_TYPE (value) = type;
6109 add_pending_init (purpose, value);
6112 constructor_incremental = 0;
6115 /* Return value of FIELD in pending initializer or zero if the field was
6116 not initialized yet. */
6119 find_init_member (field)
6122 struct init_node *p;
6124 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6126 if (constructor_incremental
6127 && tree_int_cst_lt (field, constructor_unfilled_index))
6128 set_nonincremental_init ();
6130 p = constructor_pending_elts;
6133 if (tree_int_cst_lt (field, p->purpose))
6135 else if (tree_int_cst_lt (p->purpose, field))
6141 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6143 tree bitpos = bit_position (field);
6145 if (constructor_incremental
6146 && (!constructor_unfilled_fields
6147 || tree_int_cst_lt (bitpos,
6148 bit_position (constructor_unfilled_fields))))
6149 set_nonincremental_init ();
6151 p = constructor_pending_elts;
6154 if (field == p->purpose)
6156 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6162 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6164 if (constructor_elements
6165 && TREE_PURPOSE (constructor_elements) == field)
6166 return TREE_VALUE (constructor_elements);
6171 /* "Output" the next constructor element.
6172 At top level, really output it to assembler code now.
6173 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6174 TYPE is the data type that the containing data type wants here.
6175 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6177 PENDING if non-nil means output pending elements that belong
6178 right after this element. (PENDING is normally 1;
6179 it is 0 while outputting pending elements, to avoid recursion.) */
6182 output_init_element (value, type, field, pending)
6183 tree value, type, field;
6186 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6187 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6188 && !(TREE_CODE (value) == STRING_CST
6189 && TREE_CODE (type) == ARRAY_TYPE
6190 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6191 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6192 TYPE_MAIN_VARIANT (type))))
6193 value = default_conversion (value);
6195 if (value == error_mark_node)
6196 constructor_erroneous = 1;
6197 else if (!TREE_CONSTANT (value))
6198 constructor_constant = 0;
6199 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6200 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6201 || TREE_CODE (constructor_type) == UNION_TYPE)
6202 && DECL_C_BIT_FIELD (field)
6203 && TREE_CODE (value) != INTEGER_CST))
6204 constructor_simple = 0;
6206 if (require_constant_value && ! TREE_CONSTANT (value))
6208 error_init ("initializer element is not constant");
6209 value = error_mark_node;
6211 else if (require_constant_elements
6212 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6213 pedwarn ("initializer element is not computable at load time");
6215 /* If this field is empty (and not at the end of structure),
6216 don't do anything other than checking the initializer. */
6218 && (TREE_TYPE (field) == error_mark_node
6219 || (COMPLETE_TYPE_P (TREE_TYPE (field))
6220 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6221 && (TREE_CODE (constructor_type) == ARRAY_TYPE
6222 || TREE_CHAIN (field)))))
6225 if (value == error_mark_node)
6227 constructor_erroneous = 1;
6231 /* If this element doesn't come next in sequence,
6232 put it on constructor_pending_elts. */
6233 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6234 && (!constructor_incremental
6235 || !tree_int_cst_equal (field, constructor_unfilled_index)))
6237 if (constructor_incremental
6238 && tree_int_cst_lt (field, constructor_unfilled_index))
6239 set_nonincremental_init ();
6241 add_pending_init (field,
6242 digest_init (type, value, require_constant_value,
6243 require_constant_elements));
6246 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6247 && (!constructor_incremental
6248 || field != constructor_unfilled_fields))
6250 /* We do this for records but not for unions. In a union,
6251 no matter which field is specified, it can be initialized
6252 right away since it starts at the beginning of the union. */
6253 if (constructor_incremental)
6255 if (!constructor_unfilled_fields)
6256 set_nonincremental_init ();
6259 tree bitpos, unfillpos;
6261 bitpos = bit_position (field);
6262 unfillpos = bit_position (constructor_unfilled_fields);
6264 if (tree_int_cst_lt (bitpos, unfillpos))
6265 set_nonincremental_init ();
6269 add_pending_init (field,
6270 digest_init (type, value, require_constant_value,
6271 require_constant_elements));
6274 else if (TREE_CODE (constructor_type) == UNION_TYPE
6275 && constructor_elements)
6277 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6278 warning_init ("initialized field with side-effects overwritten");
6280 /* We can have just one union field set. */
6281 constructor_elements = 0;
6284 /* Otherwise, output this element either to
6285 constructor_elements or to the assembler file. */
6287 if (field && TREE_CODE (field) == INTEGER_CST)
6288 field = copy_node (field);
6289 constructor_elements
6290 = tree_cons (field, digest_init (type, value,
6291 require_constant_value,
6292 require_constant_elements),
6293 constructor_elements);
6295 /* Advance the variable that indicates sequential elements output. */
6296 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6297 constructor_unfilled_index
6298 = size_binop (PLUS_EXPR, constructor_unfilled_index,
6300 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6302 constructor_unfilled_fields
6303 = TREE_CHAIN (constructor_unfilled_fields);
6305 /* Skip any nameless bit fields. */
6306 while (constructor_unfilled_fields != 0
6307 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6308 && DECL_NAME (constructor_unfilled_fields) == 0)
6309 constructor_unfilled_fields =
6310 TREE_CHAIN (constructor_unfilled_fields);
6312 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6313 constructor_unfilled_fields = 0;
6315 /* Now output any pending elements which have become next. */
6317 output_pending_init_elements (0);
6320 /* Output any pending elements which have become next.
6321 As we output elements, constructor_unfilled_{fields,index}
6322 advances, which may cause other elements to become next;
6323 if so, they too are output.
6325 If ALL is 0, we return when there are
6326 no more pending elements to output now.
6328 If ALL is 1, we output space as necessary so that
6329 we can output all the pending elements. */
6332 output_pending_init_elements (all)
6335 struct init_node *elt = constructor_pending_elts;
6340 /* Look thru the whole pending tree.
6341 If we find an element that should be output now,
6342 output it. Otherwise, set NEXT to the element
6343 that comes first among those still pending. */
6348 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6350 if (tree_int_cst_equal (elt->purpose,
6351 constructor_unfilled_index))
6352 output_init_element (elt->value,
6353 TREE_TYPE (constructor_type),
6354 constructor_unfilled_index, 0);
6355 else if (tree_int_cst_lt (constructor_unfilled_index,
6358 /* Advance to the next smaller node. */
6363 /* We have reached the smallest node bigger than the
6364 current unfilled index. Fill the space first. */
6365 next = elt->purpose;
6371 /* Advance to the next bigger node. */
6376 /* We have reached the biggest node in a subtree. Find
6377 the parent of it, which is the next bigger node. */
6378 while (elt->parent && elt->parent->right == elt)
6381 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6384 next = elt->purpose;
6390 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6391 || TREE_CODE (constructor_type) == UNION_TYPE)
6393 tree ctor_unfilled_bitpos, elt_bitpos;
6395 /* If the current record is complete we are done. */
6396 if (constructor_unfilled_fields == 0)
6399 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6400 elt_bitpos = bit_position (elt->purpose);
6401 /* We can't compare fields here because there might be empty
6402 fields in between. */
6403 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6405 constructor_unfilled_fields = elt->purpose;
6406 output_init_element (elt->value, TREE_TYPE (elt->purpose),
6409 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6411 /* Advance to the next smaller node. */
6416 /* We have reached the smallest node bigger than the
6417 current unfilled field. Fill the space first. */
6418 next = elt->purpose;
6424 /* Advance to the next bigger node. */
6429 /* We have reached the biggest node in a subtree. Find
6430 the parent of it, which is the next bigger node. */
6431 while (elt->parent && elt->parent->right == elt)
6435 && (tree_int_cst_lt (ctor_unfilled_bitpos,
6436 bit_position (elt->purpose))))
6438 next = elt->purpose;
6446 /* Ordinarily return, but not if we want to output all
6447 and there are elements left. */
6448 if (! (all && next != 0))
6451 /* If it's not incremental, just skip over the gap, so that after
6452 jumping to retry we will output the next successive element. */
6453 if (TREE_CODE (constructor_type) == RECORD_TYPE
6454 || TREE_CODE (constructor_type) == UNION_TYPE)
6455 constructor_unfilled_fields = next;
6456 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6457 constructor_unfilled_index = next;
6459 /* ELT now points to the node in the pending tree with the next
6460 initializer to output. */
6464 /* Add one non-braced element to the current constructor level.
6465 This adjusts the current position within the constructor's type.
6466 This may also start or terminate implicit levels
6467 to handle a partly-braced initializer.
6469 Once this has found the correct level for the new element,
6470 it calls output_init_element. */
6473 process_init_element (value)
6476 tree orig_value = value;
6477 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6479 designator_depth = 0;
6480 designator_errorneous = 0;
6482 /* Handle superfluous braces around string cst as in
6483 char x[] = {"foo"}; */
6486 && TREE_CODE (constructor_type) == ARRAY_TYPE
6487 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6488 && integer_zerop (constructor_unfilled_index))
6490 if (constructor_stack->replacement_value)
6491 error_init ("excess elements in char array initializer");
6492 constructor_stack->replacement_value = value;
6496 if (constructor_stack->replacement_value != 0)
6498 error_init ("excess elements in struct initializer");
6502 /* Ignore elements of a brace group if it is entirely superfluous
6503 and has already been diagnosed. */
6504 if (constructor_type == 0)
6507 /* If we've exhausted any levels that didn't have braces,
6509 while (constructor_stack->implicit)
6511 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6512 || TREE_CODE (constructor_type) == UNION_TYPE)
6513 && constructor_fields == 0)
6514 process_init_element (pop_init_level (1));
6515 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6516 && (constructor_max_index == 0
6517 || tree_int_cst_lt (constructor_max_index,
6518 constructor_index)))
6519 process_init_element (pop_init_level (1));
6524 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6525 if (constructor_range_stack)
6526 value = save_expr (value);
6530 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6533 enum tree_code fieldcode;
6535 if (constructor_fields == 0)
6537 pedwarn_init ("excess elements in struct initializer");
6541 fieldtype = TREE_TYPE (constructor_fields);
6542 if (fieldtype != error_mark_node)
6543 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6544 fieldcode = TREE_CODE (fieldtype);
6546 /* Accept a string constant to initialize a subarray. */
6548 && fieldcode == ARRAY_TYPE
6549 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6552 /* Otherwise, if we have come to a subaggregate,
6553 and we don't have an element of its type, push into it. */
6554 else if (value != 0 && !constructor_no_implicit
6555 && value != error_mark_node
6556 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6557 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6558 || fieldcode == UNION_TYPE))
6560 push_init_level (1);
6566 push_member_name (constructor_fields);
6567 output_init_element (value, fieldtype, constructor_fields, 1);
6568 RESTORE_SPELLING_DEPTH (constructor_depth);
6571 /* Do the bookkeeping for an element that was
6572 directly output as a constructor. */
6574 /* For a record, keep track of end position of last field. */
6575 if (DECL_SIZE (constructor_fields))
6576 constructor_bit_index
6577 = size_binop (PLUS_EXPR,
6578 bit_position (constructor_fields),
6579 DECL_SIZE (constructor_fields));
6581 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6582 /* Skip any nameless bit fields. */
6583 while (constructor_unfilled_fields != 0
6584 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6585 && DECL_NAME (constructor_unfilled_fields) == 0)
6586 constructor_unfilled_fields =
6587 TREE_CHAIN (constructor_unfilled_fields);
6590 constructor_fields = TREE_CHAIN (constructor_fields);
6591 /* Skip any nameless bit fields at the beginning. */
6592 while (constructor_fields != 0
6593 && DECL_C_BIT_FIELD (constructor_fields)
6594 && DECL_NAME (constructor_fields) == 0)
6595 constructor_fields = TREE_CHAIN (constructor_fields);
6597 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6600 enum tree_code fieldcode;
6602 if (constructor_fields == 0)
6604 pedwarn_init ("excess elements in union initializer");
6608 fieldtype = TREE_TYPE (constructor_fields);
6609 if (fieldtype != error_mark_node)
6610 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6611 fieldcode = TREE_CODE (fieldtype);
6613 /* Warn that traditional C rejects initialization of unions.
6614 We skip the warning if the value is zero. This is done
6615 under the assumption that the zero initializer in user
6616 code appears conditioned on e.g. __STDC__ to avoid
6617 "missing initializer" warnings and relies on default
6618 initialization to zero in the traditional C case. */
6619 if (warn_traditional && !in_system_header
6620 && !(value && (integer_zerop (value) || real_zerop (value))))
6621 warning ("traditional C rejects initialization of unions");
6623 /* Accept a string constant to initialize a subarray. */
6625 && fieldcode == ARRAY_TYPE
6626 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6629 /* Otherwise, if we have come to a subaggregate,
6630 and we don't have an element of its type, push into it. */
6631 else if (value != 0 && !constructor_no_implicit
6632 && value != error_mark_node
6633 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6634 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6635 || fieldcode == UNION_TYPE))
6637 push_init_level (1);
6643 push_member_name (constructor_fields);
6644 output_init_element (value, fieldtype, constructor_fields, 1);
6645 RESTORE_SPELLING_DEPTH (constructor_depth);
6648 /* Do the bookkeeping for an element that was
6649 directly output as a constructor. */
6651 constructor_bit_index = DECL_SIZE (constructor_fields);
6652 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6655 constructor_fields = 0;
6657 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6659 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6660 enum tree_code eltcode = TREE_CODE (elttype);
6662 /* Accept a string constant to initialize a subarray. */
6664 && eltcode == ARRAY_TYPE
6665 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6668 /* Otherwise, if we have come to a subaggregate,
6669 and we don't have an element of its type, push into it. */
6670 else if (value != 0 && !constructor_no_implicit
6671 && value != error_mark_node
6672 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6673 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6674 || eltcode == UNION_TYPE))
6676 push_init_level (1);
6680 if (constructor_max_index != 0
6681 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6682 || integer_all_onesp (constructor_max_index)))
6684 pedwarn_init ("excess elements in array initializer");
6688 /* Now output the actual element. */
6691 push_array_bounds (tree_low_cst (constructor_index, 0));
6692 output_init_element (value, elttype, constructor_index, 1);
6693 RESTORE_SPELLING_DEPTH (constructor_depth);
6697 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6700 /* If we are doing the bookkeeping for an element that was
6701 directly output as a constructor, we must update
6702 constructor_unfilled_index. */
6703 constructor_unfilled_index = constructor_index;
6706 /* Handle the sole element allowed in a braced initializer
6707 for a scalar variable. */
6708 else if (constructor_fields == 0)
6710 pedwarn_init ("excess elements in scalar initializer");
6716 output_init_element (value, constructor_type, NULL_TREE, 1);
6717 constructor_fields = 0;
6720 /* Handle range initializers either at this level or anywhere higher
6721 in the designator stack. */
6722 if (constructor_range_stack)
6724 struct constructor_range_stack *p, *range_stack;
6727 range_stack = constructor_range_stack;
6728 constructor_range_stack = 0;
6729 while (constructor_stack != range_stack->stack)
6731 if (!constructor_stack->implicit)
6733 process_init_element (pop_init_level (1));
6735 for (p = range_stack;
6736 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6739 if (!constructor_stack->implicit)
6741 process_init_element (pop_init_level (1));
6744 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6745 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6750 constructor_index = p->index;
6751 constructor_fields = p->fields;
6752 if (finish && p->range_end && p->index == p->range_start)
6760 push_init_level (2);
6761 p->stack = constructor_stack;
6762 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6763 p->index = p->range_start;
6767 constructor_range_stack = range_stack;
6774 constructor_range_stack = 0;
6777 /* Build a simple asm-statement, from one string literal. */
6779 simple_asm_stmt (expr)
6784 if (TREE_CODE (expr) == ADDR_EXPR)
6785 expr = TREE_OPERAND (expr, 0);
6787 if (TREE_CODE (expr) == STRING_CST)
6791 if (TREE_CHAIN (expr))
6792 expr = combine_strings (expr);
6793 stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6794 NULL_TREE, NULL_TREE,
6796 ASM_INPUT_P (stmt) = 1;
6800 error ("argument of `asm' is not a constant string");
6804 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6805 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6808 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6817 if (TREE_CHAIN (string))
6818 string = combine_strings (string);
6819 if (TREE_CODE (string) != STRING_CST)
6821 error ("asm template is not a string constant");
6825 if (cv_qualifier != NULL_TREE
6826 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6828 warning ("%s qualifier ignored on asm",
6829 IDENTIFIER_POINTER (cv_qualifier));
6830 cv_qualifier = NULL_TREE;
6833 /* We can remove output conversions that change the type,
6834 but not the mode. */
6835 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6837 tree output = TREE_VALUE (tail);
6839 STRIP_NOPS (output);
6840 TREE_VALUE (tail) = output;
6842 /* Allow conversions as LHS here. build_modify_expr as called below
6843 will do the right thing with them. */
6844 while (TREE_CODE (output) == NOP_EXPR
6845 || TREE_CODE (output) == CONVERT_EXPR
6846 || TREE_CODE (output) == FLOAT_EXPR
6847 || TREE_CODE (output) == FIX_TRUNC_EXPR
6848 || TREE_CODE (output) == FIX_FLOOR_EXPR
6849 || TREE_CODE (output) == FIX_ROUND_EXPR
6850 || TREE_CODE (output) == FIX_CEIL_EXPR)
6851 output = TREE_OPERAND (output, 0);
6853 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6856 /* Remove output conversions that change the type but not the mode. */
6857 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6859 tree output = TREE_VALUE (tail);
6860 STRIP_NOPS (output);
6861 TREE_VALUE (tail) = output;
6864 /* Perform default conversions on array and function inputs.
6865 Don't do this for other types as it would screw up operands
6866 expected to be in memory. */
6867 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6868 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6869 || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6870 TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6872 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6873 outputs, inputs, clobbers));
6876 /* Expand an ASM statement with operands, handling output operands
6877 that are not variables or INDIRECT_REFS by transforming such
6878 cases into cases that expand_asm_operands can handle.
6880 Arguments are same as for expand_asm_operands. */
6883 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6884 tree string, outputs, inputs, clobbers;
6886 const char *filename;
6889 int noutputs = list_length (outputs);
6891 /* o[I] is the place that output number I should be written. */
6892 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6895 /* Record the contents of OUTPUTS before it is modified. */
6896 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6897 o[i] = TREE_VALUE (tail);
6899 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6900 OUTPUTS some trees for where the values were actually stored. */
6901 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6903 /* Copy all the intermediate outputs into the specified outputs. */
6904 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6906 if (o[i] != TREE_VALUE (tail))
6908 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6909 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6912 /* Restore the original value so that it's correct the next
6913 time we expand this function. */
6914 TREE_VALUE (tail) = o[i];
6916 /* Detect modification of read-only values.
6917 (Otherwise done by build_modify_expr.) */
6920 tree type = TREE_TYPE (o[i]);
6921 if (TREE_READONLY (o[i])
6922 || TYPE_READONLY (type)
6923 || ((TREE_CODE (type) == RECORD_TYPE
6924 || TREE_CODE (type) == UNION_TYPE)
6925 && C_TYPE_FIELDS_READONLY (type)))
6926 readonly_warning (o[i], "modification by `asm'");
6930 /* Those MODIFY_EXPRs could do autoincrements. */
6934 /* Expand a C `return' statement.
6935 RETVAL is the expression for what to return,
6936 or a null pointer for `return;' with no value. */
6939 c_expand_return (retval)
6942 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6944 if (TREE_THIS_VOLATILE (current_function_decl))
6945 warning ("function declared `noreturn' has a `return' statement");
6949 current_function_returns_null = 1;
6950 if ((warn_return_type || flag_isoc99)
6951 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6952 pedwarn_c99 ("`return' with no value, in function returning non-void");
6954 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6956 current_function_returns_null = 1;
6957 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6958 pedwarn ("`return' with a value, in function returning void");
6962 tree t = convert_for_assignment (valtype, retval, _("return"),
6963 NULL_TREE, NULL_TREE, 0);
6964 tree res = DECL_RESULT (current_function_decl);
6967 if (t == error_mark_node)
6970 inner = t = convert (TREE_TYPE (res), t);
6972 /* Strip any conversions, additions, and subtractions, and see if
6973 we are returning the address of a local variable. Warn if so. */
6976 switch (TREE_CODE (inner))
6978 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6980 inner = TREE_OPERAND (inner, 0);
6984 /* If the second operand of the MINUS_EXPR has a pointer
6985 type (or is converted from it), this may be valid, so
6986 don't give a warning. */
6988 tree op1 = TREE_OPERAND (inner, 1);
6990 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6991 && (TREE_CODE (op1) == NOP_EXPR
6992 || TREE_CODE (op1) == NON_LVALUE_EXPR
6993 || TREE_CODE (op1) == CONVERT_EXPR))
6994 op1 = TREE_OPERAND (op1, 0);
6996 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6999 inner = TREE_OPERAND (inner, 0);
7004 inner = TREE_OPERAND (inner, 0);
7006 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7007 inner = TREE_OPERAND (inner, 0);
7009 if (TREE_CODE (inner) == VAR_DECL
7010 && ! DECL_EXTERNAL (inner)
7011 && ! TREE_STATIC (inner)
7012 && DECL_CONTEXT (inner) == current_function_decl)
7013 warning ("function returns address of local variable");
7023 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7024 current_function_returns_value = 1;
7027 return add_stmt (build_return_stmt (retval));
7031 /* The SWITCH_STMT being built. */
7033 /* A splay-tree mapping the low element of a case range to the high
7034 element, or NULL_TREE if there is no high element. Used to
7035 determine whether or not a new case label duplicates an old case
7036 label. We need a tree, rather than simply a hash table, because
7037 of the GNU case range extension. */
7039 /* The next node on the stack. */
7040 struct c_switch *next;
7043 /* A stack of the currently active switch statements. The innermost
7044 switch statement is on the top of the stack. There is no need to
7045 mark the stack for garbage collection because it is only active
7046 during the processing of the body of a function, and we never
7047 collect at that point. */
7049 static struct c_switch *switch_stack;
7051 /* Start a C switch statement, testing expression EXP. Return the new
7058 register enum tree_code code;
7060 struct c_switch *cs;
7062 if (exp != error_mark_node)
7064 code = TREE_CODE (TREE_TYPE (exp));
7065 type = TREE_TYPE (exp);
7067 if (! INTEGRAL_TYPE_P (type)
7068 && code != ERROR_MARK)
7070 error ("switch quantity not an integer");
7071 exp = integer_zero_node;
7076 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7078 if (warn_traditional && !in_system_header
7079 && (type == long_integer_type_node
7080 || type == long_unsigned_type_node))
7081 warning ("`long' switch expression not converted to `int' in ISO C");
7083 exp = default_conversion (exp);
7084 type = TREE_TYPE (exp);
7085 index = get_unwidened (exp, NULL_TREE);
7086 /* We can't strip a conversion from a signed type to an
7087 unsigned, because if we did, int_fits_type_p would do the
7088 wrong thing when checking case values for being in range,
7089 and it's too hard to do the right thing. */
7090 if (TREE_UNSIGNED (TREE_TYPE (exp))
7091 == TREE_UNSIGNED (TREE_TYPE (index)))
7096 /* Add this new SWITCH_STMT to the stack. */
7097 cs = (struct c_switch *) xmalloc (sizeof (*cs));
7098 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7099 cs->cases = splay_tree_new (case_compare, NULL, NULL);
7100 cs->next = switch_stack;
7103 return add_stmt (switch_stack->switch_stmt);
7106 /* Process a case label. */
7109 do_case (low_value, high_value)
7113 tree label = NULL_TREE;
7117 label = c_add_case_label (switch_stack->cases,
7118 SWITCH_COND (switch_stack->switch_stmt),
7119 low_value, high_value);
7120 if (label == error_mark_node)
7124 error ("case label not within a switch statement");
7126 error ("`default' label not within a switch statement");
7131 /* Finish the switch statement. */
7136 struct c_switch *cs = switch_stack;
7138 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7140 /* Pop the stack. */
7141 switch_stack = switch_stack->next;
7142 splay_tree_delete (cs->cases);