1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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). */
43 /* Nonzero if we've already printed a "missing braces around initializer"
44 message within this initializer. */
45 static int missing_braces_mentioned;
47 static tree qualify_type PROTO((tree, tree));
48 static int comp_target_types PROTO((tree, tree));
49 static int function_types_compatible_p PROTO((tree, tree));
50 static int type_lists_compatible_p PROTO((tree, tree));
51 static int self_promoting_type_p PROTO((tree));
52 static tree decl_constant_value PROTO((tree));
53 static tree lookup_field PROTO((tree, tree, tree *));
54 static tree convert_arguments PROTO((tree, tree, tree, tree));
55 static tree pointer_int_sum PROTO((enum tree_code, tree, tree));
56 static tree pointer_diff PROTO((tree, tree));
57 static tree unary_complex_lvalue PROTO((enum tree_code, tree));
58 static void pedantic_lvalue_warning PROTO((enum tree_code));
59 static tree internal_build_compound_expr PROTO((tree, int));
60 static tree convert_for_assignment PROTO((tree, tree, const char *, tree,
62 static void warn_for_assignment PROTO((const char *, const char *,
64 static tree valid_compound_expr_initializer PROTO((tree, tree));
65 static void push_string PROTO((const char *));
66 static void push_member_name PROTO((tree));
67 static void push_array_bounds PROTO((int));
68 static int spelling_length PROTO((void));
69 static char *print_spelling PROTO((char *));
70 static void warning_init PROTO((const char *));
71 static tree digest_init PROTO((tree, tree, int, int));
72 static void check_init_type_bitfields PROTO((tree));
73 static void output_init_element PROTO((tree, tree, tree, int));
74 static void output_pending_init_elements PROTO((int));
75 static void add_pending_init PROTO((tree, tree));
76 static int pending_init_member PROTO((tree));
78 /* Do `exp = require_complete_type (exp);' to make sure exp
79 does not have an incomplete type. (That includes void types.) */
82 require_complete_type (value)
85 tree type = TREE_TYPE (value);
87 if (TREE_CODE (value) == ERROR_MARK)
88 return error_mark_node;
90 /* First, detect a valid value with a complete type. */
91 if (TYPE_SIZE (type) != 0
92 && type != void_type_node)
95 incomplete_type_error (value, type);
96 return error_mark_node;
99 /* Print an error message for invalid use of an incomplete type.
100 VALUE is the expression that was used (or 0 if that isn't known)
101 and TYPE is the type that was invalid. */
104 incomplete_type_error (value, type)
108 const char *type_code_string;
110 /* Avoid duplicate error message. */
111 if (TREE_CODE (type) == ERROR_MARK)
114 if (value != 0 && (TREE_CODE (value) == VAR_DECL
115 || TREE_CODE (value) == PARM_DECL))
116 error ("`%s' has an incomplete type",
117 IDENTIFIER_POINTER (DECL_NAME (value)));
121 /* We must print an error message. Be clever about what it says. */
123 switch (TREE_CODE (type))
126 type_code_string = "struct";
130 type_code_string = "union";
134 type_code_string = "enum";
138 error ("invalid use of void expression");
142 if (TYPE_DOMAIN (type))
144 type = TREE_TYPE (type);
147 error ("invalid use of array with unspecified bounds");
154 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
155 error ("invalid use of undefined type `%s %s'",
156 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
158 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
159 error ("invalid use of incomplete typedef `%s'",
160 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
164 /* Return a variant of TYPE which has all the type qualifiers of LIKE
165 as well as those of TYPE. */
168 qualify_type (type, like)
171 return c_build_qualified_type (type,
172 TYPE_QUALS (type) | TYPE_QUALS (like));
175 /* Return the common type of two types.
176 We assume that comptypes has already been done and returned 1;
177 if that isn't so, this may crash. In particular, we assume that qualifiers
180 This is the type for the result of most arithmetic operations
181 if the operands have the given two types. */
187 register enum tree_code code1;
188 register enum tree_code code2;
191 /* Save time if the two types are the same. */
193 if (t1 == t2) return t1;
195 /* If one type is nonsense, use the other. */
196 if (t1 == error_mark_node)
198 if (t2 == error_mark_node)
201 /* Merge the attributes. */
202 attributes = merge_machine_type_attributes (t1, t2);
204 /* Treat an enum type as the unsigned integer type of the same width. */
206 if (TREE_CODE (t1) == ENUMERAL_TYPE)
207 t1 = type_for_size (TYPE_PRECISION (t1), 1);
208 if (TREE_CODE (t2) == ENUMERAL_TYPE)
209 t2 = type_for_size (TYPE_PRECISION (t2), 1);
211 code1 = TREE_CODE (t1);
212 code2 = TREE_CODE (t2);
214 /* If one type is complex, form the common type of the non-complex
215 components, then make that complex. Use T1 or T2 if it is the
217 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
219 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
220 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
221 tree subtype = common_type (subtype1, subtype2);
223 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
224 return build_type_attribute_variant (t1, attributes);
225 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
226 return build_type_attribute_variant (t2, attributes);
228 return build_type_attribute_variant (build_complex_type (subtype),
236 /* If only one is real, use it as the result. */
238 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
239 return build_type_attribute_variant (t1, attributes);
241 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
242 return build_type_attribute_variant (t2, attributes);
244 /* Both real or both integers; use the one with greater precision. */
246 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
247 return build_type_attribute_variant (t1, attributes);
248 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
249 return build_type_attribute_variant (t2, attributes);
251 /* Same precision. Prefer longs to ints even when same size. */
253 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
254 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
255 return build_type_attribute_variant (long_unsigned_type_node,
258 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
259 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
261 /* But preserve unsignedness from the other type,
262 since long cannot hold all the values of an unsigned int. */
263 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
264 t1 = long_unsigned_type_node;
266 t1 = long_integer_type_node;
267 return build_type_attribute_variant (t1, attributes);
270 /* Likewise, prefer long double to double even if same size. */
271 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
272 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
273 return build_type_attribute_variant (long_double_type_node,
276 /* Otherwise prefer the unsigned one. */
278 if (TREE_UNSIGNED (t1))
279 return build_type_attribute_variant (t1, attributes);
281 return build_type_attribute_variant (t2, attributes);
284 /* For two pointers, do this recursively on the target type,
285 and combine the qualifiers of the two types' targets. */
286 /* This code was turned off; I don't know why.
287 But ANSI C specifies doing this with the qualifiers.
288 So I turned it on again. */
290 tree pointed_to_1 = TREE_TYPE (t1);
291 tree pointed_to_2 = TREE_TYPE (t2);
292 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
293 TYPE_MAIN_VARIANT (pointed_to_2));
294 t1 = build_pointer_type (c_build_qualified_type
296 TYPE_QUALS (pointed_to_1) |
297 TYPE_QUALS (pointed_to_2)));
298 return build_type_attribute_variant (t1, attributes);
301 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
302 return build_type_attribute_variant (t1, attributes);
307 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
308 /* Save space: see if the result is identical to one of the args. */
309 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
310 return build_type_attribute_variant (t1, attributes);
311 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
312 return build_type_attribute_variant (t2, attributes);
313 /* Merge the element types, and have a size if either arg has one. */
314 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
315 return build_type_attribute_variant (t1, attributes);
319 /* Function types: prefer the one that specified arg types.
320 If both do, merge the arg types. Also merge the return types. */
322 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
323 tree p1 = TYPE_ARG_TYPES (t1);
324 tree p2 = TYPE_ARG_TYPES (t2);
329 /* Save space: see if the result is identical to one of the args. */
330 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
331 return build_type_attribute_variant (t1, attributes);
332 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
333 return build_type_attribute_variant (t2, attributes);
335 /* Simple way if one arg fails to specify argument types. */
336 if (TYPE_ARG_TYPES (t1) == 0)
338 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
339 return build_type_attribute_variant (t1, attributes);
341 if (TYPE_ARG_TYPES (t2) == 0)
343 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
344 return build_type_attribute_variant (t1, attributes);
347 /* If both args specify argument types, we must merge the two
348 lists, argument by argument. */
350 len = list_length (p1);
353 for (i = 0; i < len; i++)
354 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
359 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
361 /* A null type means arg type is not specified.
362 Take whatever the other function type has. */
363 if (TREE_VALUE (p1) == 0)
365 TREE_VALUE (n) = TREE_VALUE (p2);
368 if (TREE_VALUE (p2) == 0)
370 TREE_VALUE (n) = TREE_VALUE (p1);
374 /* Given wait (union {union wait *u; int *i} *)
375 and wait (union wait *),
376 prefer union wait * as type of parm. */
377 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
378 && TREE_VALUE (p1) != TREE_VALUE (p2))
381 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
382 memb; memb = TREE_CHAIN (memb))
383 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
385 TREE_VALUE (n) = TREE_VALUE (p2);
387 pedwarn ("function types not truly compatible in ANSI C");
391 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
392 && TREE_VALUE (p2) != TREE_VALUE (p1))
395 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
396 memb; memb = TREE_CHAIN (memb))
397 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
399 TREE_VALUE (n) = TREE_VALUE (p1);
401 pedwarn ("function types not truly compatible in ANSI C");
405 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
409 t1 = build_function_type (valtype, newargs);
410 /* ... falls through ... */
414 return build_type_attribute_variant (t1, attributes);
419 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
420 or various other operations. Return 2 if they are compatible
421 but a warning may be needed if you use them together. */
424 comptypes (type1, type2)
427 register tree t1 = type1;
428 register tree t2 = type2;
431 /* Suppress errors caused by previously reported errors. */
433 if (t1 == t2 || !t1 || !t2
434 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
437 /* Treat an enum type as the integer type of the same width and
440 if (TREE_CODE (t1) == ENUMERAL_TYPE)
441 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
442 if (TREE_CODE (t2) == ENUMERAL_TYPE)
443 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
448 /* Different classes of types can't be compatible. */
450 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
452 /* Qualifiers must match. */
454 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
457 /* Allow for two different type nodes which have essentially the same
458 definition. Note that we already checked for equality of the type
459 qualifiers (just above). */
461 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
464 #ifndef COMP_TYPE_ATTRIBUTES
465 #define COMP_TYPE_ATTRIBUTES(t1,t2) 1
468 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
469 if (! (attrval = COMP_TYPE_ATTRIBUTES (t1, t2)))
472 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
475 switch (TREE_CODE (t1))
478 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
479 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
483 val = function_types_compatible_p (t1, t2);
488 tree d1 = TYPE_DOMAIN (t1);
489 tree d2 = TYPE_DOMAIN (t2);
492 /* Target types must match incl. qualifiers. */
493 if (TREE_TYPE (t1) != TREE_TYPE (t2)
494 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
497 /* Sizes must match unless one is missing or variable. */
498 if (d1 == 0 || d2 == 0 || d1 == d2
499 || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
500 || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
501 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
502 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
505 if (! ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
506 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
507 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
508 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
509 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
510 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
511 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
512 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2)))))
518 if (maybe_objc_comptypes (t1, t2, 0) == 1)
525 return attrval == 2 && val == 1 ? 2 : val;
528 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
529 ignoring their qualifiers. */
532 comp_target_types (ttl, ttr)
537 /* Give maybe_objc_comptypes a crack at letting these types through. */
538 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
541 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
542 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
544 if (val == 2 && pedantic)
545 pedwarn ("types are not quite compatible");
549 /* Subroutines of `comptypes'. */
551 /* Return 1 if two function types F1 and F2 are compatible.
552 If either type specifies no argument types,
553 the other must specify a fixed number of self-promoting arg types.
554 Otherwise, if one type specifies only the number of arguments,
555 the other must specify that number of self-promoting arg types.
556 Otherwise, the argument types must match. */
559 function_types_compatible_p (f1, f2)
563 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
567 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
568 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
571 args1 = TYPE_ARG_TYPES (f1);
572 args2 = TYPE_ARG_TYPES (f2);
574 /* An unspecified parmlist matches any specified parmlist
575 whose argument types don't need default promotions. */
579 if (!self_promoting_args_p (args2))
581 /* If one of these types comes from a non-prototype fn definition,
582 compare that with the other type's arglist.
583 If they don't match, ask for a warning (but no error). */
584 if (TYPE_ACTUAL_ARG_TYPES (f1)
585 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
591 if (!self_promoting_args_p (args1))
593 if (TYPE_ACTUAL_ARG_TYPES (f2)
594 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
599 /* Both types have argument lists: compare them and propagate results. */
600 val1 = type_lists_compatible_p (args1, args2);
601 return val1 != 1 ? val1 : val;
604 /* Check two lists of types for compatibility,
605 returning 0 for incompatible, 1 for compatible,
606 or 2 for compatible with warning. */
609 type_lists_compatible_p (args1, args2)
612 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
618 if (args1 == 0 && args2 == 0)
620 /* If one list is shorter than the other,
621 they fail to match. */
622 if (args1 == 0 || args2 == 0)
624 /* A null pointer instead of a type
625 means there is supposed to be an argument
626 but nothing is specified about what type it has.
627 So match anything that self-promotes. */
628 if (TREE_VALUE (args1) == 0)
630 if (! self_promoting_type_p (TREE_VALUE (args2)))
633 else if (TREE_VALUE (args2) == 0)
635 if (! self_promoting_type_p (TREE_VALUE (args1)))
638 else if (! (newval = comptypes (TREE_VALUE (args1), TREE_VALUE (args2))))
640 /* Allow wait (union {union wait *u; int *i} *)
641 and wait (union wait *) to be compatible. */
642 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
643 && (TYPE_NAME (TREE_VALUE (args1)) == 0
644 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
645 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
646 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
647 TYPE_SIZE (TREE_VALUE (args2))))
650 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
651 memb; memb = TREE_CHAIN (memb))
652 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
657 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
658 && (TYPE_NAME (TREE_VALUE (args2)) == 0
659 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
660 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
661 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
662 TYPE_SIZE (TREE_VALUE (args1))))
665 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
666 memb; memb = TREE_CHAIN (memb))
667 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
676 /* comptypes said ok, but record if it said to warn. */
680 args1 = TREE_CHAIN (args1);
681 args2 = TREE_CHAIN (args2);
685 /* Return 1 if PARMS specifies a fixed number of parameters
686 and none of their types is affected by default promotions. */
689 self_promoting_args_p (parms)
693 for (t = parms; t; t = TREE_CHAIN (t))
695 register tree type = TREE_VALUE (t);
697 if (TREE_CHAIN (t) == 0 && type != void_type_node)
703 if (TYPE_MAIN_VARIANT (type) == float_type_node)
706 if (C_PROMOTING_INTEGER_TYPE_P (type))
712 /* Return 1 if TYPE is not affected by default promotions. */
715 self_promoting_type_p (type)
718 if (TYPE_MAIN_VARIANT (type) == float_type_node)
721 if (C_PROMOTING_INTEGER_TYPE_P (type))
727 /* Return an unsigned type the same as TYPE in other respects. */
733 tree type1 = TYPE_MAIN_VARIANT (type);
734 if (type1 == signed_char_type_node || type1 == char_type_node)
735 return unsigned_char_type_node;
736 if (type1 == integer_type_node)
737 return unsigned_type_node;
738 if (type1 == short_integer_type_node)
739 return short_unsigned_type_node;
740 if (type1 == long_integer_type_node)
741 return long_unsigned_type_node;
742 if (type1 == long_long_integer_type_node)
743 return long_long_unsigned_type_node;
744 if (type1 == intDI_type_node)
745 return unsigned_intDI_type_node;
746 if (type1 == intSI_type_node)
747 return unsigned_intSI_type_node;
748 if (type1 == intHI_type_node)
749 return unsigned_intHI_type_node;
750 if (type1 == intQI_type_node)
751 return unsigned_intQI_type_node;
753 return signed_or_unsigned_type (1, type);
756 /* Return a signed type the same as TYPE in other respects. */
762 tree type1 = TYPE_MAIN_VARIANT (type);
763 if (type1 == unsigned_char_type_node || type1 == char_type_node)
764 return signed_char_type_node;
765 if (type1 == unsigned_type_node)
766 return integer_type_node;
767 if (type1 == short_unsigned_type_node)
768 return short_integer_type_node;
769 if (type1 == long_unsigned_type_node)
770 return long_integer_type_node;
771 if (type1 == long_long_unsigned_type_node)
772 return long_long_integer_type_node;
773 if (type1 == unsigned_intDI_type_node)
774 return intDI_type_node;
775 if (type1 == unsigned_intSI_type_node)
776 return intSI_type_node;
777 if (type1 == unsigned_intHI_type_node)
778 return intHI_type_node;
779 if (type1 == unsigned_intQI_type_node)
780 return intQI_type_node;
782 return signed_or_unsigned_type (0, type);
785 /* Return a type the same as TYPE except unsigned or
786 signed according to UNSIGNEDP. */
789 signed_or_unsigned_type (unsignedp, type)
793 if ((! INTEGRAL_TYPE_P (type) && ! POINTER_TYPE_P (type))
794 || TREE_UNSIGNED (type) == unsignedp)
796 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
797 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
798 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
799 return unsignedp ? unsigned_type_node : integer_type_node;
800 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
801 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
802 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
803 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
804 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
805 return (unsignedp ? long_long_unsigned_type_node
806 : long_long_integer_type_node);
810 /* Compute the value of the `sizeof' operator. */
816 enum tree_code code = TREE_CODE (type);
819 if (code == FUNCTION_TYPE)
821 if (pedantic || warn_pointer_arith)
822 pedwarn ("sizeof applied to a function type");
825 if (code == VOID_TYPE)
827 if (pedantic || warn_pointer_arith)
828 pedwarn ("sizeof applied to a void type");
831 if (code == ERROR_MARK)
833 if (TYPE_SIZE (type) == 0)
835 error ("sizeof applied to an incomplete type");
839 /* Convert in case a char is more than one unit. */
840 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
841 size_int (TYPE_PRECISION (char_type_node)));
842 t = convert (sizetype, t);
843 /* size_binop does not put the constant in range, so do it now. */
844 if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
845 TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
850 c_sizeof_nowarn (type)
853 enum tree_code code = TREE_CODE (type);
856 if (code == FUNCTION_TYPE
858 || code == ERROR_MARK)
860 if (TYPE_SIZE (type) == 0)
863 /* Convert in case a char is more than one unit. */
864 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
865 size_int (TYPE_PRECISION (char_type_node)));
866 t = convert (sizetype, t);
867 force_fit_type (t, 0);
871 /* Compute the size to increment a pointer by. */
874 c_size_in_bytes (type)
877 enum tree_code code = TREE_CODE (type);
880 if (code == FUNCTION_TYPE)
882 if (code == VOID_TYPE)
884 if (code == ERROR_MARK)
886 if (TYPE_SIZE (type) == 0)
888 error ("arithmetic on pointer to an incomplete type");
892 /* Convert in case a char is more than one unit. */
893 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
894 size_int (BITS_PER_UNIT));
895 t = convert (sizetype, t);
896 force_fit_type (t, 0);
900 /* Implement the __alignof keyword: Return the minimum required
901 alignment of TYPE, measured in bytes. */
907 enum tree_code code = TREE_CODE (type);
909 if (code == FUNCTION_TYPE)
910 return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
912 if (code == VOID_TYPE || code == ERROR_MARK)
915 return size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
918 /* Implement the __alignof keyword: Return the minimum required
919 alignment of EXPR, measured in bytes. For VAR_DECL's and
920 FIELD_DECL's return DECL_ALIGN (which can be set from an
921 "aligned" __attribute__ specification). */
924 c_alignof_expr (expr)
927 if (TREE_CODE (expr) == VAR_DECL)
928 return size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
930 if (TREE_CODE (expr) == COMPONENT_REF
931 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
933 error ("`__alignof' applied to a bit-field");
936 else if (TREE_CODE (expr) == COMPONENT_REF
937 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
938 return size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
940 if (TREE_CODE (expr) == INDIRECT_REF)
942 tree t = TREE_OPERAND (expr, 0);
944 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
946 while (TREE_CODE (t) == NOP_EXPR
947 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
951 t = TREE_OPERAND (t, 0);
952 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
953 if (thisalign > bestalign)
954 best = t, bestalign = thisalign;
956 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
959 return c_alignof (TREE_TYPE (expr));
962 /* Return either DECL or its known constant value (if it has one). */
965 decl_constant_value (decl)
968 if (/* Don't change a variable array bound or initial value to a constant
969 in a place where a variable is invalid. */
970 current_function_decl != 0
972 && ! TREE_THIS_VOLATILE (decl)
973 && TREE_READONLY (decl) && ! ITERATOR_P (decl)
974 && DECL_INITIAL (decl) != 0
975 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
976 /* This is invalid if initial value is not constant.
977 If it has either a function call, a memory reference,
978 or a variable, then re-evaluating it could give different results. */
979 && TREE_CONSTANT (DECL_INITIAL (decl))
980 /* Check for cases where this is sub-optimal, even though valid. */
981 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
982 && DECL_MODE (decl) != BLKmode)
983 return DECL_INITIAL (decl);
987 /* Perform default promotions for C data used in expressions.
988 Arrays and functions are converted to pointers;
989 enumeral types or short or char, to int.
990 In addition, manifest constants symbols are replaced by their values. */
993 default_conversion (exp)
996 register tree type = TREE_TYPE (exp);
997 register enum tree_code code = TREE_CODE (type);
999 /* Constants can be used directly unless they're not loadable. */
1000 if (TREE_CODE (exp) == CONST_DECL)
1001 exp = DECL_INITIAL (exp);
1003 /* Replace a nonvolatile const static variable with its value unless
1004 it is an array, in which case we must be sure that taking the
1005 address of the array produces consistent results. */
1006 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1008 exp = decl_constant_value (exp);
1009 type = TREE_TYPE (exp);
1012 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1014 /* Do not use STRIP_NOPS here! It will remove conversions from pointer
1015 to integer and cause infinite recursion. */
1016 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1017 || (TREE_CODE (exp) == NOP_EXPR
1018 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1019 exp = TREE_OPERAND (exp, 0);
1021 /* Normally convert enums to int,
1022 but convert wide enums to something wider. */
1023 if (code == ENUMERAL_TYPE)
1025 type = type_for_size (MAX (TYPE_PRECISION (type),
1026 TYPE_PRECISION (integer_type_node)),
1028 || (TYPE_PRECISION (type)
1029 >= TYPE_PRECISION (integer_type_node)))
1030 && TREE_UNSIGNED (type)));
1031 return convert (type, exp);
1034 if (TREE_CODE (exp) == COMPONENT_REF
1035 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)))
1037 tree width = DECL_SIZE (TREE_OPERAND (exp, 1));
1038 HOST_WIDE_INT low = TREE_INT_CST_LOW (width);
1040 /* If it's thinner than an int, promote it like a
1041 C_PROMOTING_INTEGER_TYPE_P, otherwise leave it alone. */
1043 if (low < TYPE_PRECISION (integer_type_node))
1045 if (flag_traditional && TREE_UNSIGNED (type))
1046 return convert (unsigned_type_node, exp);
1048 return convert (integer_type_node, exp);
1052 if (C_PROMOTING_INTEGER_TYPE_P (type))
1054 /* Traditionally, unsignedness is preserved in default promotions.
1055 Also preserve unsignedness if not really getting any wider. */
1056 if (TREE_UNSIGNED (type)
1057 && (flag_traditional
1058 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1059 return convert (unsigned_type_node, exp);
1060 return convert (integer_type_node, exp);
1062 if (flag_traditional && !flag_allow_single_precision
1063 && TYPE_MAIN_VARIANT (type) == float_type_node)
1064 return convert (double_type_node, exp);
1065 if (code == VOID_TYPE)
1067 error ("void value not ignored as it ought to be");
1068 return error_mark_node;
1070 if (code == FUNCTION_TYPE)
1072 return build_unary_op (ADDR_EXPR, exp, 0);
1074 if (code == ARRAY_TYPE)
1077 tree restype = TREE_TYPE (type);
1082 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r'
1083 || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
1085 constp = TREE_READONLY (exp);
1086 volatilep = TREE_THIS_VOLATILE (exp);
1089 if (TYPE_QUALS (type) || constp || volatilep)
1091 = c_build_qualified_type (restype,
1093 | (constp * TYPE_QUAL_CONST)
1094 | (volatilep * TYPE_QUAL_VOLATILE));
1096 if (TREE_CODE (exp) == INDIRECT_REF)
1097 return convert (TYPE_POINTER_TO (restype),
1098 TREE_OPERAND (exp, 0));
1100 if (TREE_CODE (exp) == COMPOUND_EXPR)
1102 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1103 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1104 TREE_OPERAND (exp, 0), op1);
1107 if (! lvalue_p (exp)
1108 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1110 error ("invalid use of non-lvalue array");
1111 return error_mark_node;
1114 ptrtype = build_pointer_type (restype);
1116 if (TREE_CODE (exp) == VAR_DECL)
1118 /* ??? This is not really quite correct
1119 in that the type of the operand of ADDR_EXPR
1120 is not the target type of the type of the ADDR_EXPR itself.
1121 Question is, can this lossage be avoided? */
1122 adr = build1 (ADDR_EXPR, ptrtype, exp);
1123 if (mark_addressable (exp) == 0)
1124 return error_mark_node;
1125 TREE_CONSTANT (adr) = staticp (exp);
1126 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1129 /* This way is better for a COMPONENT_REF since it can
1130 simplify the offset for a component. */
1131 adr = build_unary_op (ADDR_EXPR, exp, 1);
1132 return convert (ptrtype, adr);
1137 /* Look up component name in the structure type definition.
1139 If this component name is found indirectly within an anonymous union,
1140 store in *INDIRECT the component which directly contains
1141 that anonymous union. Otherwise, set *INDIRECT to 0. */
1144 lookup_field (type, component, indirect)
1145 tree type, component;
1150 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1151 to the field elements. Use a binary search on this array to quickly
1152 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1153 will always be set for structures which have many elements. */
1155 if (TYPE_LANG_SPECIFIC (type))
1158 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1160 field = TYPE_FIELDS (type);
1162 top = TYPE_LANG_SPECIFIC (type)->len;
1163 while (top - bot > 1)
1165 half = (top - bot + 1) >> 1;
1166 field = field_array[bot+half];
1168 if (DECL_NAME (field) == NULL_TREE)
1170 /* Step through all anon unions in linear fashion. */
1171 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1173 tree anon = 0, junk;
1175 field = field_array[bot++];
1176 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1177 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1178 anon = lookup_field (TREE_TYPE (field), component, &junk);
1180 if (anon != NULL_TREE)
1187 /* Entire record is only anon unions. */
1191 /* Restart the binary search, with new lower bound. */
1195 if (DECL_NAME (field) == component)
1197 if (DECL_NAME (field) < component)
1203 if (DECL_NAME (field_array[bot]) == component)
1204 field = field_array[bot];
1205 else if (DECL_NAME (field) != component)
1210 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1212 if (DECL_NAME (field) == NULL_TREE)
1217 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1218 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1219 anon = lookup_field (TREE_TYPE (field), component, &junk);
1221 if (anon != NULL_TREE)
1228 if (DECL_NAME (field) == component)
1233 *indirect = NULL_TREE;
1237 /* Make an expression to refer to the COMPONENT field of
1238 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1241 build_component_ref (datum, component)
1242 tree datum, component;
1244 register tree type = TREE_TYPE (datum);
1245 register enum tree_code code = TREE_CODE (type);
1246 register tree field = NULL;
1249 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1250 unless we are not to support things not strictly ANSI. */
1251 switch (TREE_CODE (datum))
1255 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1256 return build (COMPOUND_EXPR, TREE_TYPE (value),
1257 TREE_OPERAND (datum, 0), value);
1260 return build_conditional_expr
1261 (TREE_OPERAND (datum, 0),
1262 build_component_ref (TREE_OPERAND (datum, 1), component),
1263 build_component_ref (TREE_OPERAND (datum, 2), component));
1269 /* See if there is a field or component with name COMPONENT. */
1271 if (code == RECORD_TYPE || code == UNION_TYPE)
1275 if (TYPE_SIZE (type) == 0)
1277 incomplete_type_error (NULL_TREE, type);
1278 return error_mark_node;
1281 field = lookup_field (type, component, &indirect);
1285 error (code == RECORD_TYPE
1286 ? "structure has no member named `%s'"
1287 : "union has no member named `%s'",
1288 IDENTIFIER_POINTER (component));
1289 return error_mark_node;
1291 if (TREE_TYPE (field) == error_mark_node)
1292 return error_mark_node;
1294 /* If FIELD was found buried within an anonymous union,
1295 make one COMPONENT_REF to get that anonymous union,
1296 then fall thru to make a second COMPONENT_REF to get FIELD. */
1299 ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1300 if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1301 TREE_READONLY (ref) = 1;
1302 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1303 TREE_THIS_VOLATILE (ref) = 1;
1307 ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1309 if (TREE_READONLY (datum) || TREE_READONLY (field))
1310 TREE_READONLY (ref) = 1;
1311 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1312 TREE_THIS_VOLATILE (ref) = 1;
1316 else if (code != ERROR_MARK)
1317 error ("request for member `%s' in something not a structure or union",
1318 IDENTIFIER_POINTER (component));
1320 return error_mark_node;
1323 /* Given an expression PTR for a pointer, return an expression
1324 for the value pointed to.
1325 ERRORSTRING is the name of the operator to appear in error messages. */
1328 build_indirect_ref (ptr, errorstring)
1330 const char *errorstring;
1332 register tree pointer = default_conversion (ptr);
1333 register tree type = TREE_TYPE (pointer);
1335 if (TREE_CODE (type) == POINTER_TYPE)
1337 if (TREE_CODE (pointer) == ADDR_EXPR
1339 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1340 == TREE_TYPE (type)))
1341 return TREE_OPERAND (pointer, 0);
1344 tree t = TREE_TYPE (type);
1345 register tree ref = build1 (INDIRECT_REF,
1346 TYPE_MAIN_VARIANT (t), pointer);
1348 if (TYPE_SIZE (t) == 0 && TREE_CODE (t) != ARRAY_TYPE)
1350 error ("dereferencing pointer to incomplete type");
1351 return error_mark_node;
1353 if (TREE_CODE (t) == VOID_TYPE && skip_evaluation == 0)
1354 warning ("dereferencing `void *' pointer");
1356 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1357 so that we get the proper error message if the result is used
1358 to assign to. Also, &* is supposed to be a no-op.
1359 And ANSI C seems to specify that the type of the result
1360 should be the const type. */
1361 /* A de-reference of a pointer to const is not a const. It is valid
1362 to change it via some other pointer. */
1363 TREE_READONLY (ref) = TYPE_READONLY (t);
1364 TREE_SIDE_EFFECTS (ref)
1365 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1366 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1370 else if (TREE_CODE (pointer) != ERROR_MARK)
1371 error ("invalid type argument of `%s'", errorstring);
1372 return error_mark_node;
1375 /* This handles expressions of the form "a[i]", which denotes
1378 This is logically equivalent in C to *(a+i), but we may do it differently.
1379 If A is a variable or a member, we generate a primitive ARRAY_REF.
1380 This avoids forcing the array out of registers, and can work on
1381 arrays that are not lvalues (for example, members of structures returned
1385 build_array_ref (array, index)
1390 error ("subscript missing in array reference");
1391 return error_mark_node;
1394 if (TREE_TYPE (array) == error_mark_node
1395 || TREE_TYPE (index) == error_mark_node)
1396 return error_mark_node;
1398 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1399 && TREE_CODE (array) != INDIRECT_REF)
1403 /* Subscripting with type char is likely to lose
1404 on a machine where chars are signed.
1405 So warn on any machine, but optionally.
1406 Don't warn for unsigned char since that type is safe.
1407 Don't warn for signed char because anyone who uses that
1408 must have done so deliberately. */
1409 if (warn_char_subscripts
1410 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1411 warning ("array subscript has type `char'");
1413 /* Apply default promotions *after* noticing character types. */
1414 index = default_conversion (index);
1416 /* Require integer *after* promotion, for sake of enums. */
1417 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1419 error ("array subscript is not an integer");
1420 return error_mark_node;
1423 /* An array that is indexed by a non-constant
1424 cannot be stored in a register; we must be able to do
1425 address arithmetic on its address.
1426 Likewise an array of elements of variable size. */
1427 if (TREE_CODE (index) != INTEGER_CST
1428 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
1429 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1431 if (mark_addressable (array) == 0)
1432 return error_mark_node;
1434 /* An array that is indexed by a constant value which is not within
1435 the array bounds cannot be stored in a register either; because we
1436 would get a crash in store_bit_field/extract_bit_field when trying
1437 to access a non-existent part of the register. */
1438 if (TREE_CODE (index) == INTEGER_CST
1439 && TYPE_VALUES (TREE_TYPE (array))
1440 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1442 if (mark_addressable (array) == 0)
1443 return error_mark_node;
1446 if (pedantic && !lvalue_p (array))
1448 if (DECL_REGISTER (array))
1449 pedwarn ("ANSI C forbids subscripting `register' array");
1451 pedwarn ("ANSI C forbids subscripting non-lvalue array");
1457 while (TREE_CODE (foo) == COMPONENT_REF)
1458 foo = TREE_OPERAND (foo, 0);
1459 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1460 pedwarn ("ANSI C forbids subscripting non-lvalue array");
1463 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1464 rval = build (ARRAY_REF, type, array, index);
1465 /* Array ref is const/volatile if the array elements are
1466 or if the array is. */
1467 TREE_READONLY (rval)
1468 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1469 | TREE_READONLY (array));
1470 TREE_SIDE_EFFECTS (rval)
1471 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1472 | TREE_SIDE_EFFECTS (array));
1473 TREE_THIS_VOLATILE (rval)
1474 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1475 /* This was added by rms on 16 Nov 91.
1476 It fixes vol struct foo *a; a->elts[1]
1477 in an inline function.
1478 Hope it doesn't break something else. */
1479 | TREE_THIS_VOLATILE (array));
1480 return require_complete_type (fold (rval));
1484 tree ar = default_conversion (array);
1485 tree ind = default_conversion (index);
1487 /* Do the same warning check as above, but only on the part that's
1488 syntactically the index and only if it is also semantically
1490 if (warn_char_subscripts
1491 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1492 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1493 warning ("subscript has type `char'");
1495 /* Put the integer in IND to simplify error checking. */
1496 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1503 if (ar == error_mark_node)
1506 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1507 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1509 error ("subscripted value is neither array nor pointer");
1510 return error_mark_node;
1512 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1514 error ("array subscript is not an integer");
1515 return error_mark_node;
1518 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1523 /* Build a function call to function FUNCTION with parameters PARAMS.
1524 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1525 TREE_VALUE of each node is a parameter-expression.
1526 FUNCTION's data type may be a function type or a pointer-to-function. */
1529 build_function_call (function, params)
1530 tree function, params;
1532 register tree fntype, fundecl = 0;
1533 register tree coerced_params;
1534 tree name = NULL_TREE, assembler_name = NULL_TREE;
1536 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1537 STRIP_TYPE_NOPS (function);
1539 /* Convert anything with function type to a pointer-to-function. */
1540 if (TREE_CODE (function) == FUNCTION_DECL)
1542 name = DECL_NAME (function);
1543 assembler_name = DECL_ASSEMBLER_NAME (function);
1545 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1546 (because calling an inline function does not mean the function
1547 needs to be separately compiled). */
1548 fntype = build_type_variant (TREE_TYPE (function),
1549 TREE_READONLY (function),
1550 TREE_THIS_VOLATILE (function));
1552 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1555 function = default_conversion (function);
1557 fntype = TREE_TYPE (function);
1559 if (TREE_CODE (fntype) == ERROR_MARK)
1560 return error_mark_node;
1562 if (!(TREE_CODE (fntype) == POINTER_TYPE
1563 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1565 error ("called object is not a function");
1566 return error_mark_node;
1569 /* fntype now gets the type of function pointed to. */
1570 fntype = TREE_TYPE (fntype);
1572 /* Convert the parameters to the types declared in the
1573 function prototype, or apply default promotions. */
1576 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1578 /* Check for errors in format strings. */
1580 if (warn_format && (name || assembler_name))
1581 check_function_format (name, assembler_name, coerced_params);
1583 /* Recognize certain built-in functions so we can make tree-codes
1584 other than CALL_EXPR. We do this when it enables fold-const.c
1585 to do something useful. */
1587 if (TREE_CODE (function) == ADDR_EXPR
1588 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1589 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1590 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
1595 if (coerced_params == 0)
1596 return integer_zero_node;
1597 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
1603 register tree result
1604 = build (CALL_EXPR, TREE_TYPE (fntype),
1605 function, coerced_params, NULL_TREE);
1607 TREE_SIDE_EFFECTS (result) = 1;
1608 if (TREE_TYPE (result) == void_type_node)
1610 return require_complete_type (result);
1614 /* Convert the argument expressions in the list VALUES
1615 to the types in the list TYPELIST. The result is a list of converted
1616 argument expressions.
1618 If TYPELIST is exhausted, or when an element has NULL as its type,
1619 perform the default conversions.
1621 PARMLIST is the chain of parm decls for the function being called.
1622 It may be 0, if that info is not available.
1623 It is used only for generating error messages.
1625 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1627 This is also where warnings about wrong number of args are generated.
1629 Both VALUES and the returned value are chains of TREE_LIST nodes
1630 with the elements of the list in the TREE_VALUE slots of those nodes. */
1633 convert_arguments (typelist, values, name, fundecl)
1634 tree typelist, values, name, fundecl;
1636 register tree typetail, valtail;
1637 register tree result = NULL;
1640 /* Scan the given expressions and types, producing individual
1641 converted arguments and pushing them on RESULT in reverse order. */
1643 for (valtail = values, typetail = typelist, parmnum = 0;
1645 valtail = TREE_CHAIN (valtail), parmnum++)
1647 register tree type = typetail ? TREE_VALUE (typetail) : 0;
1648 register tree val = TREE_VALUE (valtail);
1650 if (type == void_type_node)
1653 error ("too many arguments to function `%s'",
1654 IDENTIFIER_POINTER (name));
1656 error ("too many arguments to function");
1660 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1661 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1662 to convert automatically to a pointer. */
1663 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1664 val = TREE_OPERAND (val, 0);
1666 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1667 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1668 val = default_conversion (val);
1670 val = require_complete_type (val);
1674 /* Formal parm type is specified by a function prototype. */
1677 if (TYPE_SIZE (type) == 0)
1679 error ("type of formal parameter %d is incomplete", parmnum + 1);
1684 /* Optionally warn about conversions that
1685 differ from the default conversions. */
1686 if (warn_conversion)
1688 int formal_prec = TYPE_PRECISION (type);
1690 if (INTEGRAL_TYPE_P (type)
1691 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1692 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1693 else if (TREE_CODE (type) == COMPLEX_TYPE
1694 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1695 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1696 else if (TREE_CODE (type) == REAL_TYPE
1697 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1698 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1699 else if (TREE_CODE (type) == REAL_TYPE
1700 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1701 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1702 /* ??? At some point, messages should be written about
1703 conversions between complex types, but that's too messy
1705 else if (TREE_CODE (type) == REAL_TYPE
1706 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1708 /* Warn if any argument is passed as `float',
1709 since without a prototype it would be `double'. */
1710 if (formal_prec == TYPE_PRECISION (float_type_node))
1711 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1713 /* Detect integer changing in width or signedness. */
1714 else if (INTEGRAL_TYPE_P (type)
1715 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1717 tree would_have_been = default_conversion (val);
1718 tree type1 = TREE_TYPE (would_have_been);
1720 if (TREE_CODE (type) == ENUMERAL_TYPE
1721 && type == TREE_TYPE (val))
1722 /* No warning if function asks for enum
1723 and the actual arg is that enum type. */
1725 else if (formal_prec != TYPE_PRECISION (type1))
1726 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1727 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1729 /* Don't complain if the formal parameter type
1730 is an enum, because we can't tell now whether
1731 the value was an enum--even the same enum. */
1732 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1734 else if (TREE_CODE (val) == INTEGER_CST
1735 && int_fits_type_p (val, type))
1736 /* Change in signedness doesn't matter
1737 if a constant value is unaffected. */
1739 /* Likewise for a constant in a NOP_EXPR. */
1740 else if (TREE_CODE (val) == NOP_EXPR
1741 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1742 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1744 #if 0 /* We never get such tree structure here. */
1745 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1746 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1747 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1748 /* Change in signedness doesn't matter
1749 if an enum value is unaffected. */
1752 /* If the value is extended from a narrower
1753 unsigned type, it doesn't matter whether we
1754 pass it as signed or unsigned; the value
1755 certainly is the same either way. */
1756 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1757 && TREE_UNSIGNED (TREE_TYPE (val)))
1759 else if (TREE_UNSIGNED (type))
1760 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1762 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1766 parmval = convert_for_assignment (type, val,
1767 (char *) 0, /* arg passing */
1768 fundecl, name, parmnum + 1);
1770 #ifdef PROMOTE_PROTOTYPES
1771 if ((TREE_CODE (type) == INTEGER_TYPE
1772 || TREE_CODE (type) == ENUMERAL_TYPE)
1773 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1774 parmval = default_conversion (parmval);
1777 result = tree_cons (NULL_TREE, parmval, result);
1779 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1780 && (TYPE_PRECISION (TREE_TYPE (val))
1781 < TYPE_PRECISION (double_type_node)))
1782 /* Convert `float' to `double'. */
1783 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1785 /* Convert `short' and `char' to full-size `int'. */
1786 result = tree_cons (NULL_TREE, default_conversion (val), result);
1789 typetail = TREE_CHAIN (typetail);
1792 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1795 error ("too few arguments to function `%s'",
1796 IDENTIFIER_POINTER (name));
1798 error ("too few arguments to function");
1801 return nreverse (result);
1804 /* This is the entry point used by the parser
1805 for binary operators in the input.
1806 In addition to constructing the expression,
1807 we check for operands that were written with other binary operators
1808 in a way that is likely to confuse the user. */
1811 parser_build_binary_op (code, arg1, arg2)
1812 enum tree_code code;
1815 tree result = build_binary_op (code, arg1, arg2, 1);
1818 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1819 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1820 enum tree_code code1 = ERROR_MARK;
1821 enum tree_code code2 = ERROR_MARK;
1823 if (class1 == 'e' || class1 == '1'
1824 || class1 == '2' || class1 == '<')
1825 code1 = C_EXP_ORIGINAL_CODE (arg1);
1826 if (class2 == 'e' || class2 == '1'
1827 || class2 == '2' || class2 == '<')
1828 code2 = C_EXP_ORIGINAL_CODE (arg2);
1830 /* Check for cases such as x+y<<z which users are likely
1831 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1832 is cleared to prevent these warnings. */
1833 if (warn_parentheses)
1835 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1837 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1838 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1839 warning ("suggest parentheses around + or - inside shift");
1842 if (code == TRUTH_ORIF_EXPR)
1844 if (code1 == TRUTH_ANDIF_EXPR
1845 || code2 == TRUTH_ANDIF_EXPR)
1846 warning ("suggest parentheses around && within ||");
1849 if (code == BIT_IOR_EXPR)
1851 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1852 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1853 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1854 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1855 warning ("suggest parentheses around arithmetic in operand of |");
1856 /* Check cases like x|y==z */
1857 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1858 warning ("suggest parentheses around comparison in operand of |");
1861 if (code == BIT_XOR_EXPR)
1863 if (code1 == BIT_AND_EXPR
1864 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1865 || code2 == BIT_AND_EXPR
1866 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1867 warning ("suggest parentheses around arithmetic in operand of ^");
1868 /* Check cases like x^y==z */
1869 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1870 warning ("suggest parentheses around comparison in operand of ^");
1873 if (code == BIT_AND_EXPR)
1875 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1876 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1877 warning ("suggest parentheses around + or - in operand of &");
1878 /* Check cases like x&y==z */
1879 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1880 warning ("suggest parentheses around comparison in operand of &");
1884 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1885 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1886 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1887 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1889 unsigned_conversion_warning (result, arg1);
1890 unsigned_conversion_warning (result, arg2);
1891 overflow_warning (result);
1893 class = TREE_CODE_CLASS (TREE_CODE (result));
1895 /* Record the code that was specified in the source,
1896 for the sake of warnings about confusing nesting. */
1897 if (class == 'e' || class == '1'
1898 || class == '2' || class == '<')
1899 C_SET_EXP_ORIGINAL_CODE (result, code);
1902 int flag = TREE_CONSTANT (result);
1903 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1904 so that convert_for_assignment wouldn't strip it.
1905 That way, we got warnings for things like p = (1 - 1).
1906 But it turns out we should not get those warnings. */
1907 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1908 C_SET_EXP_ORIGINAL_CODE (result, code);
1909 TREE_CONSTANT (result) = flag;
1915 /* Build a binary-operation expression without default conversions.
1916 CODE is the kind of expression to build.
1917 This function differs from `build' in several ways:
1918 the data type of the result is computed and recorded in it,
1919 warnings are generated if arg data types are invalid,
1920 special handling for addition and subtraction of pointers is known,
1921 and some optimization is done (operations on narrow ints
1922 are done in the narrower type when that gives the same result).
1923 Constant folding is also done before the result is returned.
1925 Note that the operands will never have enumeral types, or function
1926 or array types, because either they will have the default conversions
1927 performed or they have both just been converted to some other type in which
1928 the arithmetic is to be done. */
1931 build_binary_op (code, orig_op0, orig_op1, convert_p)
1932 enum tree_code code;
1933 tree orig_op0, orig_op1;
1937 register enum tree_code code0, code1;
1940 /* Expression code to give to the expression when it is built.
1941 Normally this is CODE, which is what the caller asked for,
1942 but in some special cases we change it. */
1943 register enum tree_code resultcode = code;
1945 /* Data type in which the computation is to be performed.
1946 In the simplest cases this is the common type of the arguments. */
1947 register tree result_type = NULL;
1949 /* Nonzero means operands have already been type-converted
1950 in whatever way is necessary.
1951 Zero means they need to be converted to RESULT_TYPE. */
1954 /* Nonzero means create the expression with this type, rather than
1956 tree build_type = 0;
1958 /* Nonzero means after finally constructing the expression
1959 convert it to this type. */
1960 tree final_type = 0;
1962 /* Nonzero if this is an operation like MIN or MAX which can
1963 safely be computed in short if both args are promoted shorts.
1964 Also implies COMMON.
1965 -1 indicates a bitwise operation; this makes a difference
1966 in the exact conditions for when it is safe to do the operation
1967 in a narrower mode. */
1970 /* Nonzero if this is a comparison operation;
1971 if both args are promoted shorts, compare the original shorts.
1972 Also implies COMMON. */
1973 int short_compare = 0;
1975 /* Nonzero if this is a right-shift operation, which can be computed on the
1976 original short and then promoted if the operand is a promoted short. */
1977 int short_shift = 0;
1979 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1984 op0 = default_conversion (orig_op0);
1985 op1 = default_conversion (orig_op1);
1993 type0 = TREE_TYPE (op0);
1994 type1 = TREE_TYPE (op1);
1996 /* The expression codes of the data types of the arguments tell us
1997 whether the arguments are integers, floating, pointers, etc. */
1998 code0 = TREE_CODE (type0);
1999 code1 = TREE_CODE (type1);
2001 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2002 STRIP_TYPE_NOPS (op0);
2003 STRIP_TYPE_NOPS (op1);
2005 /* If an error was already reported for one of the arguments,
2006 avoid reporting another error. */
2008 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2009 return error_mark_node;
2014 /* Handle the pointer + int case. */
2015 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2016 return pointer_int_sum (PLUS_EXPR, op0, op1);
2017 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2018 return pointer_int_sum (PLUS_EXPR, op1, op0);
2024 /* Subtraction of two similar pointers.
2025 We must subtract them as integers, then divide by object size. */
2026 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2027 && comp_target_types (type0, type1))
2028 return pointer_diff (op0, op1);
2029 /* Handle pointer minus int. Just like pointer plus int. */
2030 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2031 return pointer_int_sum (MINUS_EXPR, op0, op1);
2040 case TRUNC_DIV_EXPR:
2042 case FLOOR_DIV_EXPR:
2043 case ROUND_DIV_EXPR:
2044 case EXACT_DIV_EXPR:
2045 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2046 || code0 == COMPLEX_TYPE)
2047 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2048 || code1 == COMPLEX_TYPE))
2050 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2051 resultcode = RDIV_EXPR;
2054 /* Although it would be tempting to shorten always here, that
2055 loses on some targets, since the modulo instruction is
2056 undefined if the quotient can't be represented in the
2057 computation mode. We shorten only if unsigned or if
2058 dividing by something we know != -1. */
2059 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2060 || (TREE_CODE (op1) == INTEGER_CST
2061 && (TREE_INT_CST_LOW (op1) != -1
2062 || TREE_INT_CST_HIGH (op1) != -1)));
2069 case BIT_ANDTC_EXPR:
2072 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2074 /* If one operand is a constant, and the other is a short type
2075 that has been converted to an int,
2076 really do the work in the short type and then convert the
2077 result to int. If we are lucky, the constant will be 0 or 1
2078 in the short type, making the entire operation go away. */
2079 if (TREE_CODE (op0) == INTEGER_CST
2080 && TREE_CODE (op1) == NOP_EXPR
2081 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2082 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2084 final_type = result_type;
2085 op1 = TREE_OPERAND (op1, 0);
2086 result_type = TREE_TYPE (op1);
2088 if (TREE_CODE (op1) == INTEGER_CST
2089 && TREE_CODE (op0) == NOP_EXPR
2090 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2091 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2093 final_type = result_type;
2094 op0 = TREE_OPERAND (op0, 0);
2095 result_type = TREE_TYPE (op0);
2099 case TRUNC_MOD_EXPR:
2100 case FLOOR_MOD_EXPR:
2101 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2103 /* Although it would be tempting to shorten always here, that loses
2104 on some targets, since the modulo instruction is undefined if the
2105 quotient can't be represented in the computation mode. We shorten
2106 only if unsigned or if dividing by something we know != -1. */
2107 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2108 || (TREE_CODE (op1) == INTEGER_CST
2109 && (TREE_INT_CST_LOW (op1) != -1
2110 || TREE_INT_CST_HIGH (op1) != -1)));
2115 case TRUTH_ANDIF_EXPR:
2116 case TRUTH_ORIF_EXPR:
2117 case TRUTH_AND_EXPR:
2119 case TRUTH_XOR_EXPR:
2120 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2121 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2122 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2123 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2125 /* Result of these operations is always an int,
2126 but that does not mean the operands should be
2127 converted to ints! */
2128 result_type = integer_type_node;
2129 op0 = truthvalue_conversion (op0);
2130 op1 = truthvalue_conversion (op1);
2135 /* Shift operations: result has same type as first operand;
2136 always convert second operand to int.
2137 Also set SHORT_SHIFT if shifting rightward. */
2140 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2142 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2144 if (tree_int_cst_sgn (op1) < 0)
2145 warning ("right shift count is negative");
2148 if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
2150 if (TREE_INT_CST_HIGH (op1) != 0
2151 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2152 >= TYPE_PRECISION (type0)))
2153 warning ("right shift count >= width of type");
2156 /* Use the type of the value to be shifted.
2157 This is what most traditional C compilers do. */
2158 result_type = type0;
2159 /* Unless traditional, convert the shift-count to an integer,
2160 regardless of size of value being shifted. */
2161 if (! flag_traditional)
2163 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2164 op1 = convert (integer_type_node, op1);
2165 /* Avoid converting op1 to result_type later. */
2172 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2174 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2176 if (tree_int_cst_sgn (op1) < 0)
2177 warning ("left shift count is negative");
2178 else if (TREE_INT_CST_HIGH (op1) != 0
2179 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2180 >= TYPE_PRECISION (type0)))
2181 warning ("left shift count >= width of type");
2183 /* Use the type of the value to be shifted.
2184 This is what most traditional C compilers do. */
2185 result_type = type0;
2186 /* Unless traditional, convert the shift-count to an integer,
2187 regardless of size of value being shifted. */
2188 if (! flag_traditional)
2190 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2191 op1 = convert (integer_type_node, op1);
2192 /* Avoid converting op1 to result_type later. */
2200 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2202 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2204 if (tree_int_cst_sgn (op1) < 0)
2205 warning ("shift count is negative");
2206 else if (TREE_INT_CST_HIGH (op1) != 0
2207 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2208 >= TYPE_PRECISION (type0)))
2209 warning ("shift count >= width of type");
2211 /* Use the type of the value to be shifted.
2212 This is what most traditional C compilers do. */
2213 result_type = type0;
2214 /* Unless traditional, convert the shift-count to an integer,
2215 regardless of size of value being shifted. */
2216 if (! flag_traditional)
2218 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2219 op1 = convert (integer_type_node, op1);
2220 /* Avoid converting op1 to result_type later. */
2228 /* Result of comparison is always int,
2229 but don't convert the args to int! */
2230 build_type = integer_type_node;
2231 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2232 || code0 == COMPLEX_TYPE)
2233 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2234 || code1 == COMPLEX_TYPE))
2236 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2238 register tree tt0 = TREE_TYPE (type0);
2239 register tree tt1 = TREE_TYPE (type1);
2240 /* Anything compares with void *. void * compares with anything.
2241 Otherwise, the targets must be compatible
2242 and both must be object or both incomplete. */
2243 if (comp_target_types (type0, type1))
2244 result_type = common_type (type0, type1);
2245 else if (TYPE_MAIN_VARIANT (tt0) == void_type_node)
2247 /* op0 != orig_op0 detects the case of something
2248 whose value is 0 but which isn't a valid null ptr const. */
2249 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2250 && TREE_CODE (tt1) == FUNCTION_TYPE)
2251 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2253 else if (TYPE_MAIN_VARIANT (tt1) == void_type_node)
2255 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2256 && TREE_CODE (tt0) == FUNCTION_TYPE)
2257 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2260 pedwarn ("comparison of distinct pointer types lacks a cast");
2262 if (result_type == NULL_TREE)
2263 result_type = ptr_type_node;
2265 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2266 && integer_zerop (op1))
2267 result_type = type0;
2268 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2269 && integer_zerop (op0))
2270 result_type = type1;
2271 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2273 result_type = type0;
2274 if (! flag_traditional)
2275 pedwarn ("comparison between pointer and integer");
2277 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2279 result_type = type1;
2280 if (! flag_traditional)
2281 pedwarn ("comparison between pointer and integer");
2287 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2288 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2290 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2292 if (comp_target_types (type0, type1))
2294 result_type = common_type (type0, type1);
2296 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2297 pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2301 result_type = ptr_type_node;
2302 pedwarn ("comparison of distinct pointer types lacks a cast");
2311 build_type = integer_type_node;
2312 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2313 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2315 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2317 if (comp_target_types (type0, type1))
2319 result_type = common_type (type0, type1);
2320 if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
2321 != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
2322 pedwarn ("comparison of complete and incomplete pointers");
2324 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2325 pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2329 result_type = ptr_type_node;
2330 pedwarn ("comparison of distinct pointer types lacks a cast");
2333 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2334 && integer_zerop (op1))
2336 result_type = type0;
2337 if (pedantic || extra_warnings)
2338 pedwarn ("ordered comparison of pointer with integer zero");
2340 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2341 && integer_zerop (op0))
2343 result_type = type1;
2345 pedwarn ("ordered comparison of pointer with integer zero");
2347 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2349 result_type = type0;
2350 if (! flag_traditional)
2351 pedwarn ("comparison between pointer and integer");
2353 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2355 result_type = type1;
2356 if (! flag_traditional)
2357 pedwarn ("comparison between pointer and integer");
2365 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2367 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2369 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2371 if (shorten || common || short_compare)
2372 result_type = common_type (type0, type1);
2374 /* For certain operations (which identify themselves by shorten != 0)
2375 if both args were extended from the same smaller type,
2376 do the arithmetic in that type and then extend.
2378 shorten !=0 and !=1 indicates a bitwise operation.
2379 For them, this optimization is safe only if
2380 both args are zero-extended or both are sign-extended.
2381 Otherwise, we might change the result.
2382 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2383 but calculated in (unsigned short) it would be (unsigned short)-1. */
2385 if (shorten && none_complex)
2387 int unsigned0, unsigned1;
2388 tree arg0 = get_narrower (op0, &unsigned0);
2389 tree arg1 = get_narrower (op1, &unsigned1);
2390 /* UNS is 1 if the operation to be done is an unsigned one. */
2391 int uns = TREE_UNSIGNED (result_type);
2394 final_type = result_type;
2396 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2397 but it *requires* conversion to FINAL_TYPE. */
2399 if ((TYPE_PRECISION (TREE_TYPE (op0))
2400 == TYPE_PRECISION (TREE_TYPE (arg0)))
2401 && TREE_TYPE (op0) != final_type)
2402 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2403 if ((TYPE_PRECISION (TREE_TYPE (op1))
2404 == TYPE_PRECISION (TREE_TYPE (arg1)))
2405 && TREE_TYPE (op1) != final_type)
2406 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2408 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2410 /* For bitwise operations, signedness of nominal type
2411 does not matter. Consider only how operands were extended. */
2415 /* Note that in all three cases below we refrain from optimizing
2416 an unsigned operation on sign-extended args.
2417 That would not be valid. */
2419 /* Both args variable: if both extended in same way
2420 from same width, do it in that width.
2421 Do it unsigned if args were zero-extended. */
2422 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2423 < TYPE_PRECISION (result_type))
2424 && (TYPE_PRECISION (TREE_TYPE (arg1))
2425 == TYPE_PRECISION (TREE_TYPE (arg0)))
2426 && unsigned0 == unsigned1
2427 && (unsigned0 || !uns))
2429 = signed_or_unsigned_type (unsigned0,
2430 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2431 else if (TREE_CODE (arg0) == INTEGER_CST
2432 && (unsigned1 || !uns)
2433 && (TYPE_PRECISION (TREE_TYPE (arg1))
2434 < TYPE_PRECISION (result_type))
2435 && (type = signed_or_unsigned_type (unsigned1,
2437 int_fits_type_p (arg0, type)))
2439 else if (TREE_CODE (arg1) == INTEGER_CST
2440 && (unsigned0 || !uns)
2441 && (TYPE_PRECISION (TREE_TYPE (arg0))
2442 < TYPE_PRECISION (result_type))
2443 && (type = signed_or_unsigned_type (unsigned0,
2445 int_fits_type_p (arg1, type)))
2449 /* Shifts can be shortened if shifting right. */
2454 tree arg0 = get_narrower (op0, &unsigned_arg);
2456 final_type = result_type;
2458 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2459 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2461 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2462 /* We can shorten only if the shift count is less than the
2463 number of bits in the smaller type size. */
2464 && TREE_INT_CST_HIGH (op1) == 0
2465 && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
2466 /* If arg is sign-extended and then unsigned-shifted,
2467 we can simulate this with a signed shift in arg's type
2468 only if the extended result is at least twice as wide
2469 as the arg. Otherwise, the shift could use up all the
2470 ones made by sign-extension and bring in zeros.
2471 We can't optimize that case at all, but in most machines
2472 it never happens because available widths are 2**N. */
2473 && (!TREE_UNSIGNED (final_type)
2475 || 2 * TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (result_type)))
2477 /* Do an unsigned shift if the operand was zero-extended. */
2479 = signed_or_unsigned_type (unsigned_arg,
2481 /* Convert value-to-be-shifted to that type. */
2482 if (TREE_TYPE (op0) != result_type)
2483 op0 = convert (result_type, op0);
2488 /* Comparison operations are shortened too but differently.
2489 They identify themselves by setting short_compare = 1. */
2493 /* Don't write &op0, etc., because that would prevent op0
2494 from being kept in a register.
2495 Instead, make copies of the our local variables and
2496 pass the copies by reference, then copy them back afterward. */
2497 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2498 enum tree_code xresultcode = resultcode;
2500 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2503 op0 = xop0, op1 = xop1;
2505 resultcode = xresultcode;
2507 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2508 && skip_evaluation == 0)
2510 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2511 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2513 int unsignedp0, unsignedp1;
2514 tree primop0 = get_narrower (op0, &unsignedp0);
2515 tree primop1 = get_narrower (op1, &unsignedp1);
2517 /* Avoid spurious warnings for comparison with enumerators. */
2521 STRIP_TYPE_NOPS (xop0);
2522 STRIP_TYPE_NOPS (xop1);
2524 /* Give warnings for comparisons between signed and unsigned
2525 quantities that may fail. */
2526 /* Do the checking based on the original operand trees, so that
2527 casts will be considered, but default promotions won't be. */
2529 /* Do not warn if the comparison is being done in a signed type,
2530 since the signed type will only be chosen if it can represent
2531 all the values of the unsigned type. */
2532 if (! TREE_UNSIGNED (result_type))
2534 /* Do not warn if both operands are unsigned. */
2535 else if (op0_signed == op1_signed)
2537 /* Do not warn if the signed quantity is an unsuffixed
2538 integer literal (or some static constant expression
2539 involving such literals) and it is non-negative. */
2540 else if ((op0_signed && TREE_CODE (xop0) == INTEGER_CST
2541 && tree_int_cst_sgn (xop0) >= 0)
2542 || (op1_signed && TREE_CODE (xop1) == INTEGER_CST
2543 && tree_int_cst_sgn (xop1) >= 0))
2545 /* Do not warn if the comparison is an equality operation,
2546 the unsigned quantity is an integral constant and it does
2547 not use the most significant bit of result_type. */
2548 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
2549 && ((op0_signed && TREE_CODE (xop1) == INTEGER_CST
2550 && int_fits_type_p (xop1, signed_type (result_type)))
2551 || (op1_signed && TREE_CODE (xop0) == INTEGER_CST
2552 && int_fits_type_p (xop0, signed_type (result_type)))))
2555 warning ("comparison between signed and unsigned");
2557 /* Warn if two unsigned values are being compared in a size
2558 larger than their original size, and one (and only one) is the
2559 result of a `~' operator. This comparison will always fail.
2561 Also warn if one operand is a constant, and the constant
2562 does not have all bits set that are set in the ~ operand
2563 when it is extended. */
2565 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2566 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2568 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2569 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2572 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2575 if (TREE_CODE (primop0) == INTEGER_CST
2576 || TREE_CODE (primop1) == INTEGER_CST)
2579 long constant, mask;
2580 int unsignedp, bits;
2582 if (TREE_CODE (primop0) == INTEGER_CST)
2585 unsignedp = unsignedp1;
2586 constant = TREE_INT_CST_LOW (primop0);
2591 unsignedp = unsignedp0;
2592 constant = TREE_INT_CST_LOW (primop1);
2595 bits = TYPE_PRECISION (TREE_TYPE (primop));
2596 if (bits < TYPE_PRECISION (result_type)
2597 && bits < HOST_BITS_PER_LONG && unsignedp)
2599 mask = (~0L) << bits;
2600 if ((mask & constant) != mask)
2601 warning ("comparison of promoted ~unsigned with constant");
2604 else if (unsignedp0 && unsignedp1
2605 && (TYPE_PRECISION (TREE_TYPE (primop0))
2606 < TYPE_PRECISION (result_type))
2607 && (TYPE_PRECISION (TREE_TYPE (primop1))
2608 < TYPE_PRECISION (result_type)))
2609 warning ("comparison of promoted ~unsigned with unsigned");
2615 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2616 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2617 Then the expression will be built.
2618 It will be given type FINAL_TYPE if that is nonzero;
2619 otherwise, it will be given type RESULT_TYPE. */
2623 binary_op_error (code);
2624 return error_mark_node;
2629 if (TREE_TYPE (op0) != result_type)
2630 op0 = convert (result_type, op0);
2631 if (TREE_TYPE (op1) != result_type)
2632 op1 = convert (result_type, op1);
2635 if (build_type == NULL_TREE)
2636 build_type = result_type;
2639 register tree result = build (resultcode, build_type, op0, op1);
2640 register tree folded;
2642 folded = fold (result);
2643 if (folded == result)
2644 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2645 if (final_type != 0)
2646 return convert (final_type, folded);
2651 /* Return a tree for the sum or difference (RESULTCODE says which)
2652 of pointer PTROP and integer INTOP. */
2655 pointer_int_sum (resultcode, ptrop, intop)
2656 enum tree_code resultcode;
2657 register tree ptrop, intop;
2661 register tree result;
2662 register tree folded;
2664 /* The result is a pointer of the same type that is being added. */
2666 register tree result_type = TREE_TYPE (ptrop);
2668 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2670 if (pedantic || warn_pointer_arith)
2671 pedwarn ("pointer of type `void *' used in arithmetic");
2672 size_exp = integer_one_node;
2674 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2676 if (pedantic || warn_pointer_arith)
2677 pedwarn ("pointer to a function used in arithmetic");
2678 size_exp = integer_one_node;
2681 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2683 /* If what we are about to multiply by the size of the elements
2684 contains a constant term, apply distributive law
2685 and multiply that constant term separately.
2686 This helps produce common subexpressions. */
2688 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2689 && ! TREE_CONSTANT (intop)
2690 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2691 && TREE_CONSTANT (size_exp)
2692 /* If the constant comes from pointer subtraction,
2693 skip this optimization--it would cause an error. */
2694 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2695 /* If the constant is unsigned, and smaller than the pointer size,
2696 then we must skip this optimization. This is because it could cause
2697 an overflow error if the constant is negative but INTOP is not. */
2698 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2699 || (TYPE_PRECISION (TREE_TYPE (intop))
2700 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2702 enum tree_code subcode = resultcode;
2703 tree int_type = TREE_TYPE (intop);
2704 if (TREE_CODE (intop) == MINUS_EXPR)
2705 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2706 /* Convert both subexpression types to the type of intop,
2707 because weird cases involving pointer arithmetic
2708 can result in a sum or difference with different type args. */
2709 ptrop = build_binary_op (subcode, ptrop,
2710 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2711 intop = convert (int_type, TREE_OPERAND (intop, 0));
2714 /* Convert the integer argument to a type the same size as sizetype
2715 so the multiply won't overflow spuriously. */
2717 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2718 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2719 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2720 TREE_UNSIGNED (sizetype)), intop);
2722 /* Replace the integer argument with a suitable product by the object size.
2723 Do this multiplication as signed, then convert to the appropriate
2724 pointer type (actually unsigned integral). */
2726 intop = convert (result_type,
2727 build_binary_op (MULT_EXPR, intop,
2728 convert (TREE_TYPE (intop), size_exp), 1));
2730 /* Create the sum or difference. */
2732 result = build (resultcode, result_type, ptrop, intop);
2734 folded = fold (result);
2735 if (folded == result)
2736 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2740 /* Return a tree for the difference of pointers OP0 and OP1.
2741 The resulting tree has type int. */
2744 pointer_diff (op0, op1)
2745 register tree op0, op1;
2747 register tree result, folded;
2748 tree restype = ptrdiff_type_node;
2750 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2752 if (pedantic || warn_pointer_arith)
2754 if (TREE_CODE (target_type) == VOID_TYPE)
2755 pedwarn ("pointer of type `void *' used in subtraction");
2756 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2757 pedwarn ("pointer to a function used in subtraction");
2760 /* First do the subtraction as integers;
2761 then drop through to build the divide operator.
2762 Do not do default conversions on the minus operator
2763 in case restype is a short type. */
2765 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2766 convert (restype, op1), 0);
2767 /* This generates an error if op1 is pointer to incomplete type. */
2768 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
2769 error ("arithmetic on pointer to an incomplete type");
2771 /* This generates an error if op0 is pointer to incomplete type. */
2772 op1 = c_size_in_bytes (target_type);
2774 /* Divide by the size, in easiest possible way. */
2776 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2778 folded = fold (result);
2779 if (folded == result)
2780 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2784 /* Construct and perhaps optimize a tree representation
2785 for a unary operation. CODE, a tree_code, specifies the operation
2786 and XARG is the operand. NOCONVERT nonzero suppresses
2787 the default promotions (such as from short to int). */
2790 build_unary_op (code, xarg, noconvert)
2791 enum tree_code code;
2795 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2796 register tree arg = xarg;
2797 register tree argtype = 0;
2798 register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2801 if (typecode == ERROR_MARK)
2802 return error_mark_node;
2803 if (typecode == ENUMERAL_TYPE)
2804 typecode = INTEGER_TYPE;
2809 /* This is used for unary plus, because a CONVERT_EXPR
2810 is enough to prevent anybody from looking inside for
2811 associativity, but won't generate any code. */
2812 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2813 || typecode == COMPLEX_TYPE))
2815 error ("wrong type argument to unary plus");
2816 return error_mark_node;
2818 else if (!noconvert)
2819 arg = default_conversion (arg);
2823 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2824 || typecode == COMPLEX_TYPE))
2826 error ("wrong type argument to unary minus");
2827 return error_mark_node;
2829 else if (!noconvert)
2830 arg = default_conversion (arg);
2834 if (typecode == COMPLEX_TYPE)
2838 arg = default_conversion (arg);
2840 else if (typecode != INTEGER_TYPE)
2842 error ("wrong type argument to bit-complement");
2843 return error_mark_node;
2845 else if (!noconvert)
2846 arg = default_conversion (arg);
2850 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2851 || typecode == COMPLEX_TYPE))
2853 error ("wrong type argument to abs");
2854 return error_mark_node;
2856 else if (!noconvert)
2857 arg = default_conversion (arg);
2861 /* Conjugating a real value is a no-op, but allow it anyway. */
2862 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2863 || typecode == COMPLEX_TYPE))
2865 error ("wrong type argument to conjugation");
2866 return error_mark_node;
2868 else if (!noconvert)
2869 arg = default_conversion (arg);
2872 case TRUTH_NOT_EXPR:
2873 if (typecode != INTEGER_TYPE
2874 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2875 && typecode != COMPLEX_TYPE
2876 /* These will convert to a pointer. */
2877 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2879 error ("wrong type argument to unary exclamation mark");
2880 return error_mark_node;
2882 arg = truthvalue_conversion (arg);
2883 return invert_truthvalue (arg);
2889 if (TREE_CODE (arg) == COMPLEX_CST)
2890 return TREE_REALPART (arg);
2891 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2892 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2897 if (TREE_CODE (arg) == COMPLEX_CST)
2898 return TREE_IMAGPART (arg);
2899 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2900 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2902 return convert (TREE_TYPE (arg), integer_zero_node);
2904 case PREINCREMENT_EXPR:
2905 case POSTINCREMENT_EXPR:
2906 case PREDECREMENT_EXPR:
2907 case POSTDECREMENT_EXPR:
2908 /* Handle complex lvalues (when permitted)
2909 by reduction to simpler cases. */
2911 val = unary_complex_lvalue (code, arg);
2915 /* Increment or decrement the real part of the value,
2916 and don't change the imaginary part. */
2917 if (typecode == COMPLEX_TYPE)
2921 arg = stabilize_reference (arg);
2922 real = build_unary_op (REALPART_EXPR, arg, 1);
2923 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2924 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2925 build_unary_op (code, real, 1), imag);
2928 /* Report invalid types. */
2930 if (typecode != POINTER_TYPE
2931 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2933 error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2934 ? "wrong type argument to increment"
2935 : "wrong type argument to decrement");
2936 return error_mark_node;
2941 tree result_type = TREE_TYPE (arg);
2943 arg = get_unwidened (arg, 0);
2944 argtype = TREE_TYPE (arg);
2946 /* Compute the increment. */
2948 if (typecode == POINTER_TYPE)
2950 /* If pointer target is an undefined struct,
2951 we just cannot know how to do the arithmetic. */
2952 if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
2953 error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2954 ? "increment of pointer to unknown structure"
2955 : "decrement of pointer to unknown structure");
2956 else if ((pedantic || warn_pointer_arith)
2957 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2958 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2959 pedwarn (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2960 ? "wrong type argument to increment"
2961 : "wrong type argument to decrement");
2962 inc = c_size_in_bytes (TREE_TYPE (result_type));
2965 inc = integer_one_node;
2967 inc = convert (argtype, inc);
2969 /* Handle incrementing a cast-expression. */
2972 switch (TREE_CODE (arg))
2977 case FIX_TRUNC_EXPR:
2978 case FIX_FLOOR_EXPR:
2979 case FIX_ROUND_EXPR:
2981 pedantic_lvalue_warning (CONVERT_EXPR);
2982 /* If the real type has the same machine representation
2983 as the type it is cast to, we can make better output
2984 by adding directly to the inside of the cast. */
2985 if ((TREE_CODE (TREE_TYPE (arg))
2986 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2987 && (TYPE_MODE (TREE_TYPE (arg))
2988 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2989 arg = TREE_OPERAND (arg, 0);
2992 tree incremented, modify, value;
2993 arg = stabilize_reference (arg);
2994 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2997 value = save_expr (arg);
2998 incremented = build (((code == PREINCREMENT_EXPR
2999 || code == POSTINCREMENT_EXPR)
3000 ? PLUS_EXPR : MINUS_EXPR),
3001 argtype, value, inc);
3002 TREE_SIDE_EFFECTS (incremented) = 1;
3003 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3004 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3005 TREE_USED (value) = 1;
3015 /* Complain about anything else that is not a true lvalue. */
3016 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3017 || code == POSTINCREMENT_EXPR)
3018 ? "invalid lvalue in increment"
3019 : "invalid lvalue in decrement")))
3020 return error_mark_node;
3022 /* Report a read-only lvalue. */
3023 if (TREE_READONLY (arg))
3024 readonly_warning (arg,
3025 ((code == PREINCREMENT_EXPR
3026 || code == POSTINCREMENT_EXPR)
3027 ? "increment" : "decrement"));
3029 val = build (code, TREE_TYPE (arg), arg, inc);
3030 TREE_SIDE_EFFECTS (val) = 1;
3031 val = convert (result_type, val);
3032 if (TREE_CODE (val) != code)
3033 TREE_NO_UNUSED_WARNING (val) = 1;
3038 /* Note that this operation never does default_conversion
3039 regardless of NOCONVERT. */
3041 /* Let &* cancel out to simplify resulting code. */
3042 if (TREE_CODE (arg) == INDIRECT_REF)
3044 /* Don't let this be an lvalue. */
3045 if (lvalue_p (TREE_OPERAND (arg, 0)))
3046 return non_lvalue (TREE_OPERAND (arg, 0));
3047 return TREE_OPERAND (arg, 0);
3050 /* For &x[y], return x+y */
3051 if (TREE_CODE (arg) == ARRAY_REF)
3053 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3054 return error_mark_node;
3055 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3056 TREE_OPERAND (arg, 1), 1);
3059 /* Handle complex lvalues (when permitted)
3060 by reduction to simpler cases. */
3061 val = unary_complex_lvalue (code, arg);
3065 #if 0 /* Turned off because inconsistent;
3066 float f; *&(int)f = 3.4 stores in int format
3067 whereas (int)f = 3.4 stores in float format. */
3068 /* Address of a cast is just a cast of the address
3069 of the operand of the cast. */
3070 switch (TREE_CODE (arg))
3075 case FIX_TRUNC_EXPR:
3076 case FIX_FLOOR_EXPR:
3077 case FIX_ROUND_EXPR:
3080 pedwarn ("ANSI C forbids the address of a cast expression");
3081 return convert (build_pointer_type (TREE_TYPE (arg)),
3082 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3087 /* Allow the address of a constructor if all the elements
3089 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3091 /* Anything not already handled and not a true memory reference
3093 else if (typecode != FUNCTION_TYPE
3094 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3095 return error_mark_node;
3097 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3098 argtype = TREE_TYPE (arg);
3099 /* If the lvalue is const or volatile, merge that into the type
3100 to which the address will point. Note that you can't get a
3101 restricted pointer by taking the address of something, so we
3102 only have to deal with `const' and `volatile' here. */
3103 if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
3104 || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3106 if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
3107 argtype = c_build_type_variant (argtype,
3108 TREE_READONLY (arg),
3109 TREE_THIS_VOLATILE (arg));
3112 argtype = build_pointer_type (argtype);
3114 if (mark_addressable (arg) == 0)
3115 return error_mark_node;
3120 if (TREE_CODE (arg) == COMPONENT_REF)
3122 tree field = TREE_OPERAND (arg, 1);
3124 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3126 if (DECL_C_BIT_FIELD (field))
3128 error ("attempt to take address of bit-field structure member `%s'",
3129 IDENTIFIER_POINTER (DECL_NAME (field)));
3130 return error_mark_node;
3133 addr = convert (argtype, addr);
3135 if (! integer_zerop (DECL_FIELD_BITPOS (field)))
3138 = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
3139 size_int (BITS_PER_UNIT));
3140 int flag = TREE_CONSTANT (addr);
3141 addr = fold (build (PLUS_EXPR, argtype,
3142 addr, convert (argtype, offset)));
3143 TREE_CONSTANT (addr) = flag;
3147 addr = build1 (code, argtype, arg);
3149 /* Address of a static or external variable or
3150 file-scope function counts as a constant. */
3152 && ! (TREE_CODE (arg) == FUNCTION_DECL
3153 && DECL_CONTEXT (arg) != 0))
3154 TREE_CONSTANT (addr) = 1;
3163 argtype = TREE_TYPE (arg);
3164 return fold (build1 (code, argtype, arg));
3168 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3169 convert ARG with the same conversions in the same order
3170 and return the result. */
3173 convert_sequence (conversions, arg)
3177 switch (TREE_CODE (conversions))
3182 case FIX_TRUNC_EXPR:
3183 case FIX_FLOOR_EXPR:
3184 case FIX_ROUND_EXPR:
3186 return convert (TREE_TYPE (conversions),
3187 convert_sequence (TREE_OPERAND (conversions, 0),
3196 /* Return nonzero if REF is an lvalue valid for this language.
3197 Lvalues can be assigned, unless their type has TYPE_READONLY.
3198 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3204 register enum tree_code code = TREE_CODE (ref);
3211 return lvalue_p (TREE_OPERAND (ref, 0));
3222 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3223 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3227 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3234 /* Return nonzero if REF is an lvalue valid for this language;
3235 otherwise, print an error message and return zero. */
3238 lvalue_or_else (ref, msgid)
3242 int win = lvalue_p (ref);
3248 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3249 for certain kinds of expressions which are not really lvalues
3250 but which we can accept as lvalues.
3252 If ARG is not a kind of expression we can handle, return zero. */
3255 unary_complex_lvalue (code, arg)
3256 enum tree_code code;
3259 /* Handle (a, b) used as an "lvalue". */
3260 if (TREE_CODE (arg) == COMPOUND_EXPR)
3262 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3264 /* If this returns a function type, it isn't really being used as
3265 an lvalue, so don't issue a warning about it. */
3266 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3267 pedantic_lvalue_warning (COMPOUND_EXPR);
3269 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3270 TREE_OPERAND (arg, 0), real_result);
3273 /* Handle (a ? b : c) used as an "lvalue". */
3274 if (TREE_CODE (arg) == COND_EXPR)
3276 pedantic_lvalue_warning (COND_EXPR);
3277 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3278 pedantic_lvalue_warning (COMPOUND_EXPR);
3280 return (build_conditional_expr
3281 (TREE_OPERAND (arg, 0),
3282 build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3283 build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3289 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3290 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3293 pedantic_lvalue_warning (code)
3294 enum tree_code code;
3297 pedwarn (code == COND_EXPR
3298 ? "ANSI C forbids use of conditional expressions as lvalues"
3299 : code == COMPOUND_EXPR
3300 ? "ANSI C forbids use of compound expressions as lvalues"
3301 : "ANSI C forbids use of cast expressions as lvalues");
3304 /* Warn about storing in something that is `const'. */
3307 readonly_warning (arg, msgid)
3311 /* Forbid assignments to iterators. */
3312 if (TREE_CODE (arg) == VAR_DECL && ITERATOR_P (arg))
3313 pedwarn ("%s of iterator `%s'", _(msgid),
3314 IDENTIFIER_POINTER (DECL_NAME (arg)));
3316 if (TREE_CODE (arg) == COMPONENT_REF)
3318 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3319 readonly_warning (TREE_OPERAND (arg, 0), msgid);
3321 pedwarn ("%s of read-only member `%s'", _(msgid),
3322 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3324 else if (TREE_CODE (arg) == VAR_DECL)
3325 pedwarn ("%s of read-only variable `%s'", _(msgid),
3326 IDENTIFIER_POINTER (DECL_NAME (arg)));
3328 pedwarn ("%s of read-only location", _(msgid));
3331 /* Mark EXP saying that we need to be able to take the
3332 address of it; it should not be allocated in a register.
3333 Value is 1 if successful. */
3336 mark_addressable (exp)
3339 register tree x = exp;
3341 switch (TREE_CODE (x))
3344 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3346 error ("cannot take address of bitfield `%s'",
3347 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3351 /* ... fall through ... */
3357 x = TREE_OPERAND (x, 0);
3361 TREE_ADDRESSABLE (x) = 1;
3368 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3369 && DECL_NONLOCAL (x))
3371 if (TREE_PUBLIC (x))
3373 error ("global register variable `%s' used in nested function",
3374 IDENTIFIER_POINTER (DECL_NAME (x)));
3377 pedwarn ("register variable `%s' used in nested function",
3378 IDENTIFIER_POINTER (DECL_NAME (x)));
3380 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3382 if (TREE_PUBLIC (x))
3384 error ("address of global register variable `%s' requested",
3385 IDENTIFIER_POINTER (DECL_NAME (x)));
3389 /* If we are making this addressable due to its having
3390 volatile components, give a different error message. Also
3391 handle the case of an unnamed parameter by not trying
3392 to give the name. */
3394 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3396 error ("cannot put object with volatile field into register");
3400 pedwarn ("address of register variable `%s' requested",
3401 IDENTIFIER_POINTER (DECL_NAME (x)));
3403 put_var_into_stack (x);
3407 TREE_ADDRESSABLE (x) = 1;
3408 #if 0 /* poplevel deals with this now. */
3409 if (DECL_CONTEXT (x) == 0)
3410 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3418 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3421 build_conditional_expr (ifexp, op1, op2)
3422 tree ifexp, op1, op2;
3424 register tree type1;
3425 register tree type2;
3426 register enum tree_code code1;
3427 register enum tree_code code2;
3428 register tree result_type = NULL;
3429 tree orig_op1 = op1, orig_op2 = op2;
3431 ifexp = truthvalue_conversion (default_conversion (ifexp));
3433 #if 0 /* Produces wrong result if within sizeof. */
3434 /* Don't promote the operands separately if they promote
3435 the same way. Return the unpromoted type and let the combined
3436 value get promoted if necessary. */
3438 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3439 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3440 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3441 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3443 if (TREE_CODE (ifexp) == INTEGER_CST)
3444 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3446 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3450 /* Promote both alternatives. */
3452 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3453 op1 = default_conversion (op1);
3454 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3455 op2 = default_conversion (op2);
3457 if (TREE_CODE (ifexp) == ERROR_MARK
3458 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3459 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3460 return error_mark_node;
3462 type1 = TREE_TYPE (op1);
3463 code1 = TREE_CODE (type1);
3464 type2 = TREE_TYPE (op2);
3465 code2 = TREE_CODE (type2);
3467 /* Quickly detect the usual case where op1 and op2 have the same type
3469 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3472 result_type = type1;
3474 result_type = TYPE_MAIN_VARIANT (type1);
3476 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
3477 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
3479 result_type = common_type (type1, type2);
3481 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3483 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3484 pedwarn ("ANSI C forbids conditional expr with only one void side");
3485 result_type = void_type_node;
3487 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3489 if (comp_target_types (type1, type2))
3490 result_type = common_type (type1, type2);
3491 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3492 && TREE_CODE (orig_op1) != NOP_EXPR)
3493 result_type = qualify_type (type2, type1);
3494 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3495 && TREE_CODE (orig_op2) != NOP_EXPR)
3496 result_type = qualify_type (type1, type2);
3497 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
3499 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3500 pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3501 result_type = qualify_type (type1, type2);
3503 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
3505 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3506 pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3507 result_type = qualify_type (type2, type1);
3511 pedwarn ("pointer type mismatch in conditional expression");
3512 result_type = build_pointer_type (void_type_node);
3515 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3517 if (! integer_zerop (op2))
3518 pedwarn ("pointer/integer type mismatch in conditional expression");
3521 op2 = null_pointer_node;
3522 #if 0 /* The spec seems to say this is permitted. */
3523 if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
3524 pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3527 result_type = type1;
3529 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3531 if (!integer_zerop (op1))
3532 pedwarn ("pointer/integer type mismatch in conditional expression");
3535 op1 = null_pointer_node;
3536 #if 0 /* The spec seems to say this is permitted. */
3537 if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
3538 pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3541 result_type = type2;
3546 if (flag_cond_mismatch)
3547 result_type = void_type_node;
3550 error ("type mismatch in conditional expression");
3551 return error_mark_node;
3555 /* Merge const and volatile flags of the incoming types. */
3557 = build_type_variant (result_type,
3558 TREE_READONLY (op1) || TREE_READONLY (op2),
3559 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3561 if (result_type != TREE_TYPE (op1))
3562 op1 = convert_and_check (result_type, op1);
3563 if (result_type != TREE_TYPE (op2))
3564 op2 = convert_and_check (result_type, op2);
3567 if (code1 == RECORD_TYPE || code1 == UNION_TYPE)
3569 result_type = TREE_TYPE (op1);
3570 if (TREE_CONSTANT (ifexp))
3571 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3573 if (TYPE_MODE (result_type) == BLKmode)
3575 register tree tempvar
3576 = build_decl (VAR_DECL, NULL_TREE, result_type);
3577 register tree xop1 = build_modify_expr (tempvar, op1);
3578 register tree xop2 = build_modify_expr (tempvar, op2);
3579 register tree result = fold (build (COND_EXPR, result_type,
3580 ifexp, xop1, xop2));
3582 layout_decl (tempvar, TYPE_ALIGN (result_type));
3583 /* No way to handle variable-sized objects here.
3584 I fear that the entire handling of BLKmode conditional exprs
3585 needs to be redone. */
3586 if (TREE_CODE (DECL_SIZE (tempvar)) != INTEGER_CST)
3589 = assign_stack_local (DECL_MODE (tempvar),
3590 (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
3591 + BITS_PER_UNIT - 1)
3595 TREE_SIDE_EFFECTS (result)
3596 = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
3597 | TREE_SIDE_EFFECTS (op2);
3598 return build (COMPOUND_EXPR, result_type, result, tempvar);
3603 if (TREE_CODE (ifexp) == INTEGER_CST)
3604 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3606 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3609 /* Given a list of expressions, return a compound expression
3610 that performs them all and returns the value of the last of them. */
3613 build_compound_expr (list)
3616 return internal_build_compound_expr (list, TRUE);
3620 internal_build_compound_expr (list, first_p)
3626 if (TREE_CHAIN (list) == 0)
3628 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3629 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3631 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3632 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3633 list = TREE_OPERAND (list, 0);
3636 /* Don't let (0, 0) be null pointer constant. */
3637 if (!first_p && integer_zerop (TREE_VALUE (list)))
3638 return non_lvalue (TREE_VALUE (list));
3639 return TREE_VALUE (list);
3642 if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
3644 /* Convert arrays to pointers when there really is a comma operator. */
3645 if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
3646 TREE_VALUE (TREE_CHAIN (list))
3647 = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
3650 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3652 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3654 /* The left-hand operand of a comma expression is like an expression
3655 statement: with -W or -Wunused, we should warn if it doesn't have
3656 any side-effects, unless it was explicitly cast to (void). */
3657 if ((extra_warnings || warn_unused)
3658 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3659 && TREE_TYPE (TREE_VALUE (list)) == void_type_node))
3660 warning ("left-hand operand of comma expression has no effect");
3662 /* When pedantic, a compound expression can be neither an lvalue
3663 nor an integer constant expression. */
3668 /* With -Wunused, we should also warn if the left-hand operand does have
3669 side-effects, but computes a value which is not used. For example, in
3670 `foo() + bar(), baz()' the result of the `+' operator is not used,
3671 so we should issue a warning. */
3672 else if (warn_unused)
3673 warn_if_unused_value (TREE_VALUE (list));
3675 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3678 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3681 build_c_cast (type, expr)
3685 register tree value = expr;
3687 if (type == error_mark_node || expr == error_mark_node)
3688 return error_mark_node;
3689 type = TYPE_MAIN_VARIANT (type);
3692 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3693 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3694 value = TREE_OPERAND (value, 0);
3697 if (TREE_CODE (type) == ARRAY_TYPE)
3699 error ("cast specifies array type");
3700 return error_mark_node;
3703 if (TREE_CODE (type) == FUNCTION_TYPE)
3705 error ("cast specifies function type");
3706 return error_mark_node;
3709 if (type == TREE_TYPE (value))
3713 if (TREE_CODE (type) == RECORD_TYPE
3714 || TREE_CODE (type) == UNION_TYPE)
3715 pedwarn ("ANSI C forbids casting nonscalar to the same type");
3718 else if (TREE_CODE (type) == UNION_TYPE)
3721 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3722 || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3723 value = default_conversion (value);
3725 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3726 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3727 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3736 pedwarn ("ANSI C forbids casts to union type");
3737 if (TYPE_NAME (type) != 0)
3739 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3740 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3742 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3746 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3747 build_tree_list (field, value)),
3749 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3752 error ("cast to union type from type not present in union");
3753 return error_mark_node;
3759 /* If casting to void, avoid the error that would come
3760 from default_conversion in the case of a non-lvalue array. */
3761 if (type == void_type_node)
3762 return build1 (CONVERT_EXPR, type, value);
3764 /* Convert functions and arrays to pointers,
3765 but don't convert any other types. */
3766 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3767 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3768 value = default_conversion (value);
3769 otype = TREE_TYPE (value);
3771 /* Optionally warn about potentially worrisome casts. */
3774 && TREE_CODE (type) == POINTER_TYPE
3775 && TREE_CODE (otype) == POINTER_TYPE)
3777 /* Go to the innermost object being pointed to. */
3778 tree in_type = type;
3779 tree in_otype = otype;
3781 while (TREE_CODE (in_type) == POINTER_TYPE)
3782 in_type = TREE_TYPE (in_type);
3783 while (TREE_CODE (in_otype) == POINTER_TYPE)
3784 in_otype = TREE_TYPE (in_otype);
3786 if (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type))
3787 /* There are qualifiers present in IN_OTYPE that are not
3788 present in IN_TYPE. */
3789 pedwarn ("cast discards qualifiers from pointer target type");
3792 /* Warn about possible alignment problems. */
3793 if (STRICT_ALIGNMENT && warn_cast_align
3794 && TREE_CODE (type) == POINTER_TYPE
3795 && TREE_CODE (otype) == POINTER_TYPE
3796 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3797 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3798 /* Don't warn about opaque types, where the actual alignment
3799 restriction is unknown. */
3800 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3801 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3802 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3803 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3804 warning ("cast increases required alignment of target type");
3806 if (TREE_CODE (type) == INTEGER_TYPE
3807 && TREE_CODE (otype) == POINTER_TYPE
3808 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3809 && !TREE_CONSTANT (value))
3810 warning ("cast from pointer to integer of different size");
3812 if (warn_bad_function_cast
3813 && TREE_CODE (value) == CALL_EXPR
3814 && TREE_CODE (type) != TREE_CODE (otype))
3815 warning ("cast does not match function type");
3817 if (TREE_CODE (type) == POINTER_TYPE
3818 && TREE_CODE (otype) == INTEGER_TYPE
3819 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3821 /* Don't warn about converting 0 to pointer,
3822 provided the 0 was explicit--not cast or made by folding. */
3823 && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
3825 /* Don't warn about converting any constant. */
3826 && !TREE_CONSTANT (value))
3827 warning ("cast to pointer from integer of different size");
3830 value = convert (type, value);
3832 /* Ignore any integer overflow caused by the cast. */
3833 if (TREE_CODE (value) == INTEGER_CST)
3835 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3836 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3840 /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant. */
3841 if (pedantic && TREE_CODE (value) == INTEGER_CST
3842 && TREE_CODE (expr) == INTEGER_CST
3843 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3844 value = non_lvalue (value);
3846 /* If pedantic, don't let a cast be an lvalue. */
3847 if (value == expr && pedantic)
3848 value = non_lvalue (value);
3853 /* Build an assignment expression of lvalue LHS from value RHS.
3854 MODIFYCODE is the code for a binary operator that we use
3855 to combine the old value of LHS with RHS to get the new value.
3856 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3859 build_modify_expr (lhs, modifycode, rhs)
3861 enum tree_code modifycode;
3863 register tree result;
3865 tree lhstype = TREE_TYPE (lhs);
3866 tree olhstype = lhstype;
3868 /* Types that aren't fully specified cannot be used in assignments. */
3869 lhs = require_complete_type (lhs);
3871 /* Avoid duplicate error messages from operands that had errors. */
3872 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3873 return error_mark_node;
3875 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3876 /* Do not use STRIP_NOPS here. We do not want an enumerator
3877 whose value is 0 to count as a null pointer constant. */
3878 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3879 rhs = TREE_OPERAND (rhs, 0);
3883 /* Handle control structure constructs used as "lvalues". */
3885 switch (TREE_CODE (lhs))
3887 /* Handle (a, b) used as an "lvalue". */
3889 pedantic_lvalue_warning (COMPOUND_EXPR);
3890 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
3892 if (TREE_CODE (newrhs) == ERROR_MARK)
3893 return error_mark_node;
3894 return build (COMPOUND_EXPR, lhstype,
3895 TREE_OPERAND (lhs, 0), newrhs);
3897 /* Handle (a ? b : c) used as an "lvalue". */
3899 pedantic_lvalue_warning (COND_EXPR);
3900 rhs = save_expr (rhs);
3902 /* Produce (a ? (b = rhs) : (c = rhs))
3903 except that the RHS goes through a save-expr
3904 so the code to compute it is only emitted once. */
3906 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3907 build_modify_expr (TREE_OPERAND (lhs, 1),
3909 build_modify_expr (TREE_OPERAND (lhs, 2),
3911 if (TREE_CODE (cond) == ERROR_MARK)
3913 /* Make sure the code to compute the rhs comes out
3914 before the split. */
3915 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3916 /* But cast it to void to avoid an "unused" error. */
3917 convert (void_type_node, rhs), cond);
3923 /* If a binary op has been requested, combine the old LHS value with the RHS
3924 producing the value we should actually store into the LHS. */
3926 if (modifycode != NOP_EXPR)
3928 lhs = stabilize_reference (lhs);
3929 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3932 /* Handle a cast used as an "lvalue".
3933 We have already performed any binary operator using the value as cast.
3934 Now convert the result to the cast type of the lhs,
3935 and then true type of the lhs and store it there;
3936 then convert result back to the cast type to be the value
3937 of the assignment. */
3939 switch (TREE_CODE (lhs))
3944 case FIX_TRUNC_EXPR:
3945 case FIX_FLOOR_EXPR:
3946 case FIX_ROUND_EXPR:
3948 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3949 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3950 newrhs = default_conversion (newrhs);
3952 tree inner_lhs = TREE_OPERAND (lhs, 0);
3954 result = build_modify_expr (inner_lhs, NOP_EXPR,
3955 convert (TREE_TYPE (inner_lhs),
3956 convert (lhstype, newrhs)));
3957 if (TREE_CODE (result) == ERROR_MARK)
3959 pedantic_lvalue_warning (CONVERT_EXPR);
3960 return convert (TREE_TYPE (lhs), result);
3967 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3968 Reject anything strange now. */
3970 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3971 return error_mark_node;
3973 /* Warn about storing in something that is `const'. */
3975 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3976 || ((TREE_CODE (lhstype) == RECORD_TYPE
3977 || TREE_CODE (lhstype) == UNION_TYPE)
3978 && C_TYPE_FIELDS_READONLY (lhstype)))
3979 readonly_warning (lhs, "assignment");
3981 /* If storing into a structure or union member,
3982 it has probably been given type `int'.
3983 Compute the type that would go with
3984 the actual amount of storage the member occupies. */
3986 if (TREE_CODE (lhs) == COMPONENT_REF
3987 && (TREE_CODE (lhstype) == INTEGER_TYPE
3988 || TREE_CODE (lhstype) == REAL_TYPE
3989 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3990 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3992 /* If storing in a field that is in actuality a short or narrower than one,
3993 we must store in the field in its actual type. */
3995 if (lhstype != TREE_TYPE (lhs))
3997 lhs = copy_node (lhs);
3998 TREE_TYPE (lhs) = lhstype;
4001 /* Convert new value to destination type. */
4003 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4004 NULL_TREE, NULL_TREE, 0);
4005 if (TREE_CODE (newrhs) == ERROR_MARK)
4006 return error_mark_node;
4008 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4009 TREE_SIDE_EFFECTS (result) = 1;
4011 /* If we got the LHS in a different type for storing in,
4012 convert the result back to the nominal type of LHS
4013 so that the value we return always has the same type
4014 as the LHS argument. */
4016 if (olhstype == TREE_TYPE (result))
4018 return convert_for_assignment (olhstype, result, _("assignment"),
4019 NULL_TREE, NULL_TREE, 0);
4022 /* Convert value RHS to type TYPE as preparation for an assignment
4023 to an lvalue of type TYPE.
4024 The real work of conversion is done by `convert'.
4025 The purpose of this function is to generate error messages
4026 for assignments that are not allowed in C.
4027 ERRTYPE is a string to use in error messages:
4028 "assignment", "return", etc. If it is null, this is parameter passing
4029 for a function call (and different error messages are output).
4031 FUNNAME is the name of the function being called,
4032 as an IDENTIFIER_NODE, or null.
4033 PARMNUM is the number of the argument, for printing in error messages. */
4036 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4038 const char *errtype;
4039 tree fundecl, funname;
4042 register enum tree_code codel = TREE_CODE (type);
4043 register tree rhstype;
4044 register enum tree_code coder;
4046 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4047 /* Do not use STRIP_NOPS here. We do not want an enumerator
4048 whose value is 0 to count as a null pointer constant. */
4049 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4050 rhs = TREE_OPERAND (rhs, 0);
4052 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4053 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4054 rhs = default_conversion (rhs);
4055 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4056 rhs = decl_constant_value (rhs);
4058 rhstype = TREE_TYPE (rhs);
4059 coder = TREE_CODE (rhstype);
4061 if (coder == ERROR_MARK)
4062 return error_mark_node;
4064 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4066 overflow_warning (rhs);
4067 /* Check for Objective-C protocols. This will issue a warning if
4068 there are protocol violations. No need to use the return value. */
4069 maybe_objc_comptypes (type, rhstype, 0);
4073 if (coder == VOID_TYPE)
4075 error ("void value not ignored as it ought to be");
4076 return error_mark_node;
4078 /* Arithmetic types all interconvert, and enum is treated like int. */
4079 if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE
4080 || codel == COMPLEX_TYPE)
4081 && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE
4082 || coder == COMPLEX_TYPE))
4083 return convert_and_check (type, rhs);
4085 /* Conversion to a transparent union from its member types.
4086 This applies only to function arguments. */
4087 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4090 tree marginal_memb_type = 0;
4092 for (memb_types = TYPE_FIELDS (type); memb_types;
4093 memb_types = TREE_CHAIN (memb_types))
4095 tree memb_type = TREE_TYPE (memb_types);
4097 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4098 TYPE_MAIN_VARIANT (rhstype)))
4101 if (TREE_CODE (memb_type) != POINTER_TYPE)
4104 if (coder == POINTER_TYPE)
4106 register tree ttl = TREE_TYPE (memb_type);
4107 register tree ttr = TREE_TYPE (rhstype);
4109 /* Any non-function converts to a [const][volatile] void *
4110 and vice versa; otherwise, targets must be the same.
4111 Meanwhile, the lhs target must have all the qualifiers of
4113 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4114 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4115 || comp_target_types (memb_type, rhstype))
4117 /* If this type won't generate any warnings, use it. */
4118 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4119 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4120 && TREE_CODE (ttl) == FUNCTION_TYPE)
4121 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4122 == TYPE_QUALS (ttr))
4123 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4124 == TYPE_QUALS (ttl))))
4127 /* Keep looking for a better type, but remember this one. */
4128 if (! marginal_memb_type)
4129 marginal_memb_type = memb_type;
4133 /* Can convert integer zero to any pointer type. */
4134 if (integer_zerop (rhs)
4135 || (TREE_CODE (rhs) == NOP_EXPR
4136 && integer_zerop (TREE_OPERAND (rhs, 0))))
4138 rhs = null_pointer_node;
4143 if (memb_types || marginal_memb_type)
4147 /* We have only a marginally acceptable member type;
4148 it needs a warning. */
4149 register tree ttl = TREE_TYPE (marginal_memb_type);
4150 register tree ttr = TREE_TYPE (rhstype);
4152 /* Const and volatile mean something different for function
4153 types, so the usual warnings are not appropriate. */
4154 if (TREE_CODE (ttr) == FUNCTION_TYPE
4155 && TREE_CODE (ttl) == FUNCTION_TYPE)
4157 /* Because const and volatile on functions are
4158 restrictions that say the function will not do
4159 certain things, it is okay to use a const or volatile
4160 function where an ordinary one is wanted, but not
4162 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4163 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4164 errtype, funname, parmnum);
4166 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4167 warn_for_assignment ("%s discards qualifiers from pointer target type",
4172 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4173 pedwarn ("ANSI C prohibits argument conversion to union type");
4175 return build1 (NOP_EXPR, type, rhs);
4179 /* Conversions among pointers */
4180 else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
4182 register tree ttl = TREE_TYPE (type);
4183 register tree ttr = TREE_TYPE (rhstype);
4185 /* Any non-function converts to a [const][volatile] void *
4186 and vice versa; otherwise, targets must be the same.
4187 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4188 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4189 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4190 || comp_target_types (type, rhstype)
4191 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4192 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4195 && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
4196 && TREE_CODE (ttr) == FUNCTION_TYPE)
4198 (TYPE_MAIN_VARIANT (ttr) == void_type_node
4199 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4200 which are not ANSI null ptr constants. */
4201 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4202 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4203 warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
4204 errtype, funname, parmnum);
4205 /* Const and volatile mean something different for function types,
4206 so the usual warnings are not appropriate. */
4207 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4208 && TREE_CODE (ttl) != FUNCTION_TYPE)
4210 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4211 warn_for_assignment ("%s discards qualifiers from pointer target type",
4212 errtype, funname, parmnum);
4213 /* If this is not a case of ignoring a mismatch in signedness,
4215 else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4216 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4217 || comp_target_types (type, rhstype))
4219 /* If there is a mismatch, do warn. */
4221 warn_for_assignment ("pointer targets in %s differ in signedness",
4222 errtype, funname, parmnum);
4224 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4225 && TREE_CODE (ttr) == FUNCTION_TYPE)
4227 /* Because const and volatile on functions are restrictions
4228 that say the function will not do certain things,
4229 it is okay to use a const or volatile function
4230 where an ordinary one is wanted, but not vice-versa. */
4231 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4232 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4233 errtype, funname, parmnum);
4237 warn_for_assignment ("%s from incompatible pointer type",
4238 errtype, funname, parmnum);
4239 return convert (type, rhs);
4241 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4243 /* An explicit constant 0 can convert to a pointer,
4244 or one that results from arithmetic, even including
4245 a cast to integer type. */
4246 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4248 ! (TREE_CODE (rhs) == NOP_EXPR
4249 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4250 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4251 && integer_zerop (TREE_OPERAND (rhs, 0))))
4253 warn_for_assignment ("%s makes pointer from integer without a cast",
4254 errtype, funname, parmnum);
4255 return convert (type, rhs);
4257 return null_pointer_node;
4259 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4261 warn_for_assignment ("%s makes integer from pointer without a cast",
4262 errtype, funname, parmnum);
4263 return convert (type, rhs);
4270 tree selector = maybe_building_objc_message_expr ();
4272 if (selector && parmnum > 2)
4273 error ("incompatible type for argument %d of `%s'",
4274 parmnum - 2, IDENTIFIER_POINTER (selector));
4276 error ("incompatible type for argument %d of `%s'",
4277 parmnum, IDENTIFIER_POINTER (funname));
4280 error ("incompatible type for argument %d of indirect function call",
4284 error ("incompatible types in %s", errtype);
4286 return error_mark_node;
4289 /* Print a warning using MSGID.
4290 It gets OPNAME as its one parameter.
4291 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4292 FUNCTION and ARGNUM are handled specially if we are building an
4293 Objective-C selector. */
4296 warn_for_assignment (msgid, opname, function, argnum)
4304 tree selector = maybe_building_objc_message_expr ();
4307 if (selector && argnum > 2)
4309 function = selector;
4314 /* Function name is known; supply it. */
4315 const char *argstring = _("passing arg %d of `%s'");
4316 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4317 + strlen (argstring) + 1 + 25
4319 sprintf (new_opname, argstring, argnum,
4320 IDENTIFIER_POINTER (function));
4324 /* Function name unknown (call through ptr); just give arg number.*/
4325 const char *argnofun = _("passing arg %d of pointer to function");
4326 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4327 sprintf (new_opname, argnofun, argnum);
4329 opname = new_opname;
4331 pedwarn (msgid, opname);
4334 /* Return nonzero if VALUE is a valid constant-valued expression
4335 for use in initializing a static variable; one that can be an
4336 element of a "constant" initializer.
4338 Return null_pointer_node if the value is absolute;
4339 if it is relocatable, return the variable that determines the relocation.
4340 We assume that VALUE has been folded as much as possible;
4341 therefore, we do not need to check for such things as
4342 arithmetic-combinations of integers. */
4345 initializer_constant_valid_p (value, endtype)
4349 switch (TREE_CODE (value))
4352 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4353 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4354 && TREE_CONSTANT (value)
4355 && CONSTRUCTOR_ELTS (value))
4357 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4360 return TREE_STATIC (value) ? null_pointer_node : 0;
4366 return null_pointer_node;
4369 return TREE_OPERAND (value, 0);
4371 case NON_LVALUE_EXPR:
4372 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4376 /* Allow conversions between pointer types. */
4377 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
4378 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
4379 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4381 /* Allow conversions between real types. */
4382 if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
4383 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
4384 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4386 /* Allow length-preserving conversions between integer types. */
4387 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4388 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
4389 && (TYPE_PRECISION (TREE_TYPE (value))
4390 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4391 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4393 /* Allow conversions between other integer types only if
4395 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4396 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
4398 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4400 if (inner == null_pointer_node)
4401 return null_pointer_node;
4405 /* Allow (int) &foo provided int is as wide as a pointer. */
4406 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4407 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
4408 && (TYPE_PRECISION (TREE_TYPE (value))
4409 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4410 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4413 /* Likewise conversions from int to pointers, but also allow
4414 conversions from 0. */
4415 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
4416 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
4418 if (integer_zerop (TREE_OPERAND (value, 0)))
4419 return null_pointer_node;
4420 else if (TYPE_PRECISION (TREE_TYPE (value))
4421 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4422 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4426 /* Allow conversions to union types if the value inside is okay. */
4427 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4428 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4433 if (TREE_CODE (endtype) == INTEGER_TYPE
4434 && TYPE_PRECISION (endtype) < POINTER_SIZE)
4437 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4439 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4441 /* If either term is absolute, use the other terms relocation. */
4442 if (valid0 == null_pointer_node)
4444 if (valid1 == null_pointer_node)
4450 if (TREE_CODE (endtype) == INTEGER_TYPE
4451 && TYPE_PRECISION (endtype) < POINTER_SIZE)
4454 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4456 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4458 /* Win if second argument is absolute. */
4459 if (valid1 == null_pointer_node)
4461 /* Win if both arguments have the same relocation.
4462 Then the value is absolute. */
4463 if (valid0 == valid1)
4464 return null_pointer_node;
4473 /* If VALUE is a compound expr all of whose expressions are constant, then
4474 return its value. Otherwise, return error_mark_node.
4476 This is for handling COMPOUND_EXPRs as initializer elements
4477 which is allowed with a warning when -pedantic is specified. */
4480 valid_compound_expr_initializer (value, endtype)
4484 if (TREE_CODE (value) == COMPOUND_EXPR)
4486 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4488 return error_mark_node;
4489 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4492 else if (! TREE_CONSTANT (value)
4493 && ! initializer_constant_valid_p (value, endtype))
4494 return error_mark_node;
4499 /* Perform appropriate conversions on the initial value of a variable,
4500 store it in the declaration DECL,
4501 and print any error messages that are appropriate.
4502 If the init is invalid, store an ERROR_MARK. */
4505 store_init_value (decl, init)
4508 register tree value, type;
4510 /* If variable's type was invalidly declared, just ignore it. */
4512 type = TREE_TYPE (decl);
4513 if (TREE_CODE (type) == ERROR_MARK)
4516 /* Digest the specified initializer into an expression. */
4518 value = digest_init (type, init, TREE_STATIC (decl),
4519 TREE_STATIC (decl) || pedantic);
4521 /* Store the expression if valid; else report error. */
4524 /* Note that this is the only place we can detect the error
4525 in a case such as struct foo bar = (struct foo) { x, y };
4526 where there is one initial value which is a constructor expression. */
4527 if (value == error_mark_node)
4529 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4531 error ("initializer for static variable is not constant");
4532 value = error_mark_node;
4534 else if (TREE_STATIC (decl)
4535 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4537 error ("initializer for static variable uses complicated arithmetic");
4538 value = error_mark_node;
4542 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4544 if (! TREE_CONSTANT (value))
4545 pedwarn ("aggregate initializer is not constant");
4546 else if (! TREE_STATIC (value))
4547 pedwarn ("aggregate initializer uses complicated arithmetic");
4552 DECL_INITIAL (decl) = value;
4554 /* ANSI wants warnings about out-of-range constant initializers. */
4555 STRIP_TYPE_NOPS (value);
4556 constant_expression_warning (value);
4559 /* Methods for storing and printing names for error messages. */
4561 /* Implement a spelling stack that allows components of a name to be pushed
4562 and popped. Each element on the stack is this structure. */
4574 #define SPELLING_STRING 1
4575 #define SPELLING_MEMBER 2
4576 #define SPELLING_BOUNDS 3
4578 static struct spelling *spelling; /* Next stack element (unused). */
4579 static struct spelling *spelling_base; /* Spelling stack base. */
4580 static int spelling_size; /* Size of the spelling stack. */
4582 /* Macros to save and restore the spelling stack around push_... functions.
4583 Alternative to SAVE_SPELLING_STACK. */
4585 #define SPELLING_DEPTH() (spelling - spelling_base)
4586 #define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4588 /* Save and restore the spelling stack around arbitrary C code. */
4590 #define SAVE_SPELLING_DEPTH(code) \
4592 int __depth = SPELLING_DEPTH (); \
4594 RESTORE_SPELLING_DEPTH (__depth); \
4597 /* Push an element on the spelling stack with type KIND and assign VALUE
4600 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4602 int depth = SPELLING_DEPTH (); \
4604 if (depth >= spelling_size) \
4606 spelling_size += 10; \
4607 if (spelling_base == 0) \
4609 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4612 = (struct spelling *) xrealloc (spelling_base, \
4613 spelling_size * sizeof (struct spelling)); \
4614 RESTORE_SPELLING_DEPTH (depth); \
4617 spelling->kind = (KIND); \
4618 spelling->MEMBER = (VALUE); \
4622 /* Push STRING on the stack. Printed literally. */
4625 push_string (string)
4628 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4631 /* Push a member name on the stack. Printed as '.' STRING. */
4634 push_member_name (decl)
4639 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4640 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4643 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4646 push_array_bounds (bounds)
4649 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4652 /* Compute the maximum size in bytes of the printed spelling. */
4657 register int size = 0;
4658 register struct spelling *p;
4660 for (p = spelling_base; p < spelling; p++)
4662 if (p->kind == SPELLING_BOUNDS)
4665 size += strlen (p->u.s) + 1;
4671 /* Print the spelling to BUFFER and return it. */
4674 print_spelling (buffer)
4675 register char *buffer;
4677 register char *d = buffer;
4678 register struct spelling *p;
4680 for (p = spelling_base; p < spelling; p++)
4681 if (p->kind == SPELLING_BOUNDS)
4683 sprintf (d, "[%d]", p->u.i);
4688 register const char *s;
4689 if (p->kind == SPELLING_MEMBER)
4691 for (s = p->u.s; (*d = *s++); d++)
4698 /* Issue an error message for a bad initializer component.
4699 MSGID identifies the message.
4700 The component name is taken from the spelling stack. */
4709 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4711 error ("(near initialization for `%s')", ofwhat);
4714 /* Issue a pedantic warning for a bad initializer component.
4715 MSGID identifies the message.
4716 The component name is taken from the spelling stack. */
4719 pedwarn_init (msgid)
4725 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4727 pedwarn ("(near initialization for `%s')", ofwhat);
4730 /* Issue a warning for a bad initializer component.
4731 MSGID identifies the message.
4732 The component name is taken from the spelling stack. */
4735 warning_init (msgid)
4741 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4743 warning ("(near initialization for `%s')", ofwhat);
4746 /* Digest the parser output INIT as an initializer for type TYPE.
4747 Return a C expression of type TYPE to represent the initial value.
4749 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4750 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4751 applies only to elements of constructors. */
4754 digest_init (type, init, require_constant, constructor_constant)
4756 int require_constant, constructor_constant;
4758 enum tree_code code = TREE_CODE (type);
4759 tree inside_init = init;
4761 if (init == error_mark_node)
4764 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4765 /* Do not use STRIP_NOPS here. We do not want an enumerator
4766 whose value is 0 to count as a null pointer constant. */
4767 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4768 inside_init = TREE_OPERAND (init, 0);
4770 /* Initialization of an array of chars from a string constant
4771 optionally enclosed in braces. */
4773 if (code == ARRAY_TYPE)
4775 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4776 if ((typ1 == char_type_node
4777 || typ1 == signed_char_type_node
4778 || typ1 == unsigned_char_type_node
4779 || typ1 == unsigned_wchar_type_node
4780 || typ1 == signed_wchar_type_node)
4781 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4783 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4784 TYPE_MAIN_VARIANT (type)))
4787 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4789 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4791 error_init ("char-array initialized from wide string");
4792 return error_mark_node;
4794 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4796 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4798 error_init ("int-array initialized from non-wide string");
4799 return error_mark_node;
4802 TREE_TYPE (inside_init) = type;
4803 if (TYPE_DOMAIN (type) != 0
4804 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
4806 register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
4807 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4808 /* Subtract 1 (or sizeof (wchar_t))
4809 because it's ok to ignore the terminating null char
4810 that is counted in the length of the constant. */
4811 if (size < TREE_STRING_LENGTH (inside_init)
4812 - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
4813 ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
4815 pedwarn_init ("initializer-string for array of chars is too long");
4821 /* Any type can be initialized
4822 from an expression of the same type, optionally with braces. */
4824 if (inside_init && TREE_TYPE (inside_init) != 0
4825 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4826 TYPE_MAIN_VARIANT (type))
4827 || (code == ARRAY_TYPE
4828 && comptypes (TREE_TYPE (inside_init), type))
4829 || (code == POINTER_TYPE
4830 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4831 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4832 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4833 TREE_TYPE (type)))))
4835 if (code == POINTER_TYPE
4836 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4837 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4838 inside_init = default_conversion (inside_init);
4839 else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4840 && TREE_CODE (inside_init) != CONSTRUCTOR)
4842 error_init ("array initialized from non-constant array expression");
4843 return error_mark_node;
4846 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4847 inside_init = decl_constant_value (inside_init);
4849 /* Compound expressions can only occur here if -pedantic or
4850 -pedantic-errors is specified. In the later case, we always want
4851 an error. In the former case, we simply want a warning. */
4852 if (require_constant && pedantic
4853 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4856 = valid_compound_expr_initializer (inside_init,
4857 TREE_TYPE (inside_init));
4858 if (inside_init == error_mark_node)
4859 error_init ("initializer element is not constant");
4861 pedwarn_init ("initializer element is not constant");
4862 if (flag_pedantic_errors)
4863 inside_init = error_mark_node;
4865 else if (require_constant && ! TREE_CONSTANT (inside_init))
4867 error_init ("initializer element is not constant");
4868 inside_init = error_mark_node;
4870 else if (require_constant
4871 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4873 error_init ("initializer element is not computable at load time");
4874 inside_init = error_mark_node;
4880 /* Handle scalar types, including conversions. */
4882 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4883 || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4885 /* Note that convert_for_assignment calls default_conversion
4886 for arrays and functions. We must not call it in the
4887 case where inside_init is a null pointer constant. */
4889 = convert_for_assignment (type, init, _("initialization"),
4890 NULL_TREE, NULL_TREE, 0);
4892 if (require_constant && ! TREE_CONSTANT (inside_init))
4894 error_init ("initializer element is not constant");
4895 inside_init = error_mark_node;
4897 else if (require_constant
4898 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4900 error_init ("initializer element is not computable at load time");
4901 inside_init = error_mark_node;
4907 /* Come here only for records and arrays. */
4909 if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4911 error_init ("variable-sized object may not be initialized");
4912 return error_mark_node;
4915 /* Traditionally, you can write struct foo x = 0;
4916 and it initializes the first element of x to 0. */
4917 if (flag_traditional)
4919 tree top = 0, prev = 0, otype = type;
4920 while (TREE_CODE (type) == RECORD_TYPE
4921 || TREE_CODE (type) == ARRAY_TYPE
4922 || TREE_CODE (type) == QUAL_UNION_TYPE
4923 || TREE_CODE (type) == UNION_TYPE)
4925 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4929 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4931 if (TREE_CODE (type) == ARRAY_TYPE)
4932 type = TREE_TYPE (type);
4933 else if (TYPE_FIELDS (type))
4934 type = TREE_TYPE (TYPE_FIELDS (type));
4937 error_init ("invalid initializer");
4938 return error_mark_node;
4944 TREE_OPERAND (prev, 1)
4945 = build_tree_list (NULL_TREE,
4946 digest_init (type, init, require_constant,
4947 constructor_constant));
4951 return error_mark_node;
4953 error_init ("invalid initializer");
4954 return error_mark_node;
4957 /* Handle initializers that use braces. */
4959 /* Type of object we are accumulating a constructor for.
4960 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4961 static tree constructor_type;
4963 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4965 static tree constructor_fields;
4967 /* For an ARRAY_TYPE, this is the specified index
4968 at which to store the next element we get.
4969 This is a special INTEGER_CST node that we modify in place. */
4970 static tree constructor_index;
4972 /* For an ARRAY_TYPE, this is the end index of the range
4973 to initialize with the next element, or NULL in the ordinary case
4974 where the element is used just once. */
4975 static tree constructor_range_end;
4977 /* For an ARRAY_TYPE, this is the maximum index. */
4978 static tree constructor_max_index;
4980 /* For a RECORD_TYPE, this is the first field not yet written out. */
4981 static tree constructor_unfilled_fields;
4983 /* For an ARRAY_TYPE, this is the index of the first element
4984 not yet written out.
4985 This is a special INTEGER_CST node that we modify in place. */
4986 static tree constructor_unfilled_index;
4988 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4989 This is so we can generate gaps between fields, when appropriate.
4990 This is a special INTEGER_CST node that we modify in place. */
4991 static tree constructor_bit_index;
4993 /* If we are saving up the elements rather than allocating them,
4994 this is the list of elements so far (in reverse order,
4995 most recent first). */
4996 static tree constructor_elements;
4998 /* 1 if so far this constructor's elements are all compile-time constants. */
4999 static int constructor_constant;
5001 /* 1 if so far this constructor's elements are all valid address constants. */
5002 static int constructor_simple;
5004 /* 1 if this constructor is erroneous so far. */
5005 static int constructor_erroneous;
5007 /* 1 if have called defer_addressed_constants. */
5008 static int constructor_subconstants_deferred;
5010 /* Structure for managing pending initializer elements, organized as an
5015 struct init_node *left, *right;
5016 struct init_node *parent;
5022 /* Tree of pending elements at this constructor level.
5023 These are elements encountered out of order
5024 which belong at places we haven't reached yet in actually
5025 writing the output. */
5026 static struct init_node *constructor_pending_elts;
5028 /* The SPELLING_DEPTH of this constructor. */
5029 static int constructor_depth;
5031 /* 0 if implicitly pushing constructor levels is allowed. */
5032 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
5034 static int require_constant_value;
5035 static int require_constant_elements;
5037 /* 1 if it is ok to output this constructor as we read it.
5038 0 means must accumulate a CONSTRUCTOR expression. */
5039 static int constructor_incremental;
5041 /* DECL node for which an initializer is being read.
5042 0 means we are reading a constructor expression
5043 such as (struct foo) {...}. */
5044 static tree constructor_decl;
5046 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
5047 static char *constructor_asmspec;
5049 /* Nonzero if this is an initializer for a top-level decl. */
5050 static int constructor_top_level;
5053 /* This stack has a level for each implicit or explicit level of
5054 structuring in the initializer, including the outermost one. It
5055 saves the values of most of the variables above. */
5057 struct constructor_stack
5059 struct constructor_stack *next;
5065 tree unfilled_index;
5066 tree unfilled_fields;
5070 struct init_node *pending_elts;
5072 /* If nonzero, this value should replace the entire
5073 constructor at this level. */
5074 tree replacement_value;
5083 struct constructor_stack *constructor_stack;
5085 /* This stack records separate initializers that are nested.
5086 Nested initializers can't happen in ANSI C, but GNU C allows them
5087 in cases like { ... (struct foo) { ... } ... }. */
5089 struct initializer_stack
5091 struct initializer_stack *next;
5094 struct constructor_stack *constructor_stack;
5096 struct spelling *spelling;
5097 struct spelling *spelling_base;
5101 char require_constant_value;
5102 char require_constant_elements;
5106 struct initializer_stack *initializer_stack;
5108 /* Prepare to parse and output the initializer for variable DECL. */
5111 start_init (decl, asmspec_tree, top_level)
5117 struct initializer_stack *p
5118 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5122 asmspec = TREE_STRING_POINTER (asmspec_tree);
5124 p->decl = constructor_decl;
5125 p->asmspec = constructor_asmspec;
5126 p->incremental = constructor_incremental;
5127 p->require_constant_value = require_constant_value;
5128 p->require_constant_elements = require_constant_elements;
5129 p->constructor_stack = constructor_stack;
5130 p->elements = constructor_elements;
5131 p->spelling = spelling;
5132 p->spelling_base = spelling_base;
5133 p->spelling_size = spelling_size;
5134 p->deferred = constructor_subconstants_deferred;
5135 p->top_level = constructor_top_level;
5136 p->next = initializer_stack;
5137 initializer_stack = p;
5139 constructor_decl = decl;
5140 constructor_incremental = top_level;
5141 constructor_asmspec = asmspec;
5142 constructor_subconstants_deferred = 0;
5143 constructor_top_level = top_level;
5147 require_constant_value = TREE_STATIC (decl);
5148 require_constant_elements
5149 = ((TREE_STATIC (decl) || pedantic)
5150 /* For a scalar, you can always use any value to initialize,
5151 even within braces. */
5152 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5153 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5154 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5155 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5156 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5157 constructor_incremental |= TREE_STATIC (decl);
5161 require_constant_value = 0;
5162 require_constant_elements = 0;
5163 locus = "(anonymous)";
5166 constructor_stack = 0;
5168 missing_braces_mentioned = 0;
5172 RESTORE_SPELLING_DEPTH (0);
5175 push_string (locus);
5181 struct initializer_stack *p = initializer_stack;
5183 /* Output subconstants (string constants, usually)
5184 that were referenced within this initializer and saved up.
5185 Must do this if and only if we called defer_addressed_constants. */
5186 if (constructor_subconstants_deferred)
5187 output_deferred_addressed_constants ();
5189 /* Free the whole constructor stack of this initializer. */
5190 while (constructor_stack)
5192 struct constructor_stack *q = constructor_stack;
5193 constructor_stack = q->next;
5197 /* Pop back to the data of the outer initializer (if any). */
5198 constructor_decl = p->decl;
5199 constructor_asmspec = p->asmspec;
5200 constructor_incremental = p->incremental;
5201 require_constant_value = p->require_constant_value;
5202 require_constant_elements = p->require_constant_elements;
5203 constructor_stack = p->constructor_stack;
5204 constructor_elements = p->elements;
5205 spelling = p->spelling;
5206 spelling_base = p->spelling_base;
5207 spelling_size = p->spelling_size;
5208 constructor_subconstants_deferred = p->deferred;
5209 constructor_top_level = p->top_level;
5210 initializer_stack = p->next;
5214 /* Call here when we see the initializer is surrounded by braces.
5215 This is instead of a call to push_init_level;
5216 it is matched by a call to pop_init_level.
5218 TYPE is the type to initialize, for a constructor expression.
5219 For an initializer for a decl, TYPE is zero. */
5222 really_start_incremental_init (type)
5225 struct constructor_stack *p
5226 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5229 type = TREE_TYPE (constructor_decl);
5231 /* Turn off constructor_incremental if type is a struct with bitfields.
5232 Do this before the first push, so that the corrected value
5233 is available in finish_init. */
5234 check_init_type_bitfields (type);
5236 p->type = constructor_type;
5237 p->fields = constructor_fields;
5238 p->index = constructor_index;
5239 p->range_end = constructor_range_end;
5240 p->max_index = constructor_max_index;
5241 p->unfilled_index = constructor_unfilled_index;
5242 p->unfilled_fields = constructor_unfilled_fields;
5243 p->bit_index = constructor_bit_index;
5244 p->elements = constructor_elements;
5245 p->constant = constructor_constant;
5246 p->simple = constructor_simple;
5247 p->erroneous = constructor_erroneous;
5248 p->pending_elts = constructor_pending_elts;
5249 p->depth = constructor_depth;
5250 p->replacement_value = 0;
5252 p->incremental = constructor_incremental;
5255 constructor_stack = p;
5257 constructor_constant = 1;
5258 constructor_simple = 1;
5259 constructor_depth = SPELLING_DEPTH ();
5260 constructor_elements = 0;
5261 constructor_pending_elts = 0;
5262 constructor_type = type;
5264 if (TREE_CODE (constructor_type) == RECORD_TYPE
5265 || TREE_CODE (constructor_type) == UNION_TYPE)
5267 constructor_fields = TYPE_FIELDS (constructor_type);
5268 /* Skip any nameless bit fields at the beginning. */
5269 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5270 && DECL_NAME (constructor_fields) == 0)
5271 constructor_fields = TREE_CHAIN (constructor_fields);
5272 constructor_unfilled_fields = constructor_fields;
5273 constructor_bit_index = copy_node (integer_zero_node);
5274 TREE_TYPE (constructor_bit_index) = sbitsizetype;
5276 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5278 constructor_range_end = 0;
5279 if (TYPE_DOMAIN (constructor_type))
5281 constructor_max_index
5282 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5284 = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5287 constructor_index = copy_node (integer_zero_node);
5288 constructor_unfilled_index = copy_node (constructor_index);
5292 /* Handle the case of int x = {5}; */
5293 constructor_fields = constructor_type;
5294 constructor_unfilled_fields = constructor_type;
5297 if (constructor_incremental)
5299 int momentary = suspend_momentary ();
5300 push_obstacks_nochange ();
5301 if (TREE_PERMANENT (constructor_decl))
5302 end_temporary_allocation ();
5303 make_decl_rtl (constructor_decl, constructor_asmspec,
5304 constructor_top_level);
5305 assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5307 resume_momentary (momentary);
5310 if (constructor_incremental)
5312 defer_addressed_constants ();
5313 constructor_subconstants_deferred = 1;
5317 /* Push down into a subobject, for initialization.
5318 If this is for an explicit set of braces, IMPLICIT is 0.
5319 If it is because the next element belongs at a lower level,
5323 push_init_level (implicit)
5326 struct constructor_stack *p;
5328 /* If we've exhausted any levels that didn't have braces,
5330 while (constructor_stack->implicit)
5332 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5333 || TREE_CODE (constructor_type) == UNION_TYPE)
5334 && constructor_fields == 0)
5335 process_init_element (pop_init_level (1));
5336 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5337 && tree_int_cst_lt (constructor_max_index, constructor_index))
5338 process_init_element (pop_init_level (1));
5343 /* Structure elements may require alignment. Do this now if necessary
5344 for the subaggregate, and if it comes next in sequence. Don't do
5345 this for subaggregates that will go on the pending list. */
5346 if (constructor_incremental && constructor_type != 0
5347 && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
5348 && constructor_fields == constructor_unfilled_fields)
5350 /* Advance to offset of this element. */
5351 if (! tree_int_cst_equal (constructor_bit_index,
5352 DECL_FIELD_BITPOS (constructor_fields)))
5354 /* By using unsigned arithmetic, the result will be correct even
5355 in case of overflows, if BITS_PER_UNIT is a power of two. */
5356 unsigned next = (TREE_INT_CST_LOW
5357 (DECL_FIELD_BITPOS (constructor_fields))
5358 / (unsigned)BITS_PER_UNIT);
5359 unsigned here = (TREE_INT_CST_LOW (constructor_bit_index)
5360 / (unsigned)BITS_PER_UNIT);
5362 assemble_zeros ((next - here)
5363 * (unsigned)BITS_PER_UNIT
5364 / (unsigned)BITS_PER_UNIT);
5366 /* Indicate that we have now filled the structure up to the current
5368 constructor_unfilled_fields = constructor_fields;
5371 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5372 p->type = constructor_type;
5373 p->fields = constructor_fields;
5374 p->index = constructor_index;
5375 p->range_end = constructor_range_end;
5376 p->max_index = constructor_max_index;
5377 p->unfilled_index = constructor_unfilled_index;
5378 p->unfilled_fields = constructor_unfilled_fields;
5379 p->bit_index = constructor_bit_index;
5380 p->elements = constructor_elements;
5381 p->constant = constructor_constant;
5382 p->simple = constructor_simple;
5383 p->erroneous = constructor_erroneous;
5384 p->pending_elts = constructor_pending_elts;
5385 p->depth = constructor_depth;
5386 p->replacement_value = 0;
5387 p->implicit = implicit;
5388 p->incremental = constructor_incremental;
5390 p->next = constructor_stack;
5391 constructor_stack = p;
5393 constructor_constant = 1;
5394 constructor_simple = 1;
5395 constructor_depth = SPELLING_DEPTH ();
5396 constructor_elements = 0;
5397 constructor_pending_elts = 0;
5399 /* Don't die if an entire brace-pair level is superfluous
5400 in the containing level. */
5401 if (constructor_type == 0)
5403 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5404 || TREE_CODE (constructor_type) == UNION_TYPE)
5406 /* Don't die if there are extra init elts at the end. */
5407 if (constructor_fields == 0)
5408 constructor_type = 0;
5411 constructor_type = TREE_TYPE (constructor_fields);
5412 push_member_name (constructor_fields);
5413 constructor_depth++;
5414 if (constructor_fields != constructor_unfilled_fields)
5415 constructor_incremental = 0;
5418 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5420 constructor_type = TREE_TYPE (constructor_type);
5421 push_array_bounds (TREE_INT_CST_LOW (constructor_index));
5422 constructor_depth++;
5423 if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5424 || constructor_range_end != 0)
5425 constructor_incremental = 0;
5428 if (constructor_type == 0)
5430 error_init ("extra brace group at end of initializer");
5431 constructor_fields = 0;
5432 constructor_unfilled_fields = 0;
5436 /* Turn off constructor_incremental if type is a struct with bitfields. */
5437 check_init_type_bitfields (constructor_type);
5439 if (implicit && warn_missing_braces && !missing_braces_mentioned)
5441 missing_braces_mentioned = 1;
5442 warning_init ("missing braces around initializer");
5445 if (TREE_CODE (constructor_type) == RECORD_TYPE
5446 || TREE_CODE (constructor_type) == UNION_TYPE)
5448 constructor_fields = TYPE_FIELDS (constructor_type);
5449 /* Skip any nameless bit fields at the beginning. */
5450 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5451 && DECL_NAME (constructor_fields) == 0)
5452 constructor_fields = TREE_CHAIN (constructor_fields);
5453 constructor_unfilled_fields = constructor_fields;
5454 constructor_bit_index = copy_node (integer_zero_node);
5455 TREE_TYPE (constructor_bit_index) = sbitsizetype;
5457 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5459 constructor_range_end = 0;
5460 if (TYPE_DOMAIN (constructor_type))
5462 constructor_max_index
5463 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5465 = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5468 constructor_index = copy_node (integer_zero_node);
5469 constructor_unfilled_index = copy_node (constructor_index);
5473 warning_init ("braces around scalar initializer");
5474 constructor_fields = constructor_type;
5475 constructor_unfilled_fields = constructor_type;
5479 /* Don't read a struct incrementally if it has any bitfields,
5480 because the incremental reading code doesn't know how to
5481 handle bitfields yet. */
5484 check_init_type_bitfields (type)
5487 if (TREE_CODE (type) == RECORD_TYPE)
5490 for (tail = TYPE_FIELDS (type); tail;
5491 tail = TREE_CHAIN (tail))
5493 if (DECL_C_BIT_FIELD (tail))
5495 constructor_incremental = 0;
5499 check_init_type_bitfields (TREE_TYPE (tail));
5503 else if (TREE_CODE (type) == UNION_TYPE)
5505 tree tail = TYPE_FIELDS (type);
5506 if (tail && DECL_C_BIT_FIELD (tail))
5507 /* We also use the nonincremental algorithm for initiliazation
5508 of unions whose first member is a bitfield, becuase the
5509 incremental algorithm has no code for dealing with
5511 constructor_incremental = 0;
5514 else if (TREE_CODE (type) == ARRAY_TYPE)
5515 check_init_type_bitfields (TREE_TYPE (type));
5518 /* At the end of an implicit or explicit brace level,
5519 finish up that level of constructor.
5520 If we were outputting the elements as they are read, return 0
5521 from inner levels (process_init_element ignores that),
5522 but return error_mark_node from the outermost level
5523 (that's what we want to put in DECL_INITIAL).
5524 Otherwise, return a CONSTRUCTOR expression. */
5527 pop_init_level (implicit)
5530 struct constructor_stack *p;
5532 tree constructor = 0;
5536 /* When we come to an explicit close brace,
5537 pop any inner levels that didn't have explicit braces. */
5538 while (constructor_stack->implicit)
5539 process_init_element (pop_init_level (1));
5542 p = constructor_stack;
5544 if (constructor_type != 0)
5545 size = int_size_in_bytes (constructor_type);
5547 /* Warn when some struct elements are implicitly initialized to zero. */
5550 && TREE_CODE (constructor_type) == RECORD_TYPE
5551 && constructor_unfilled_fields)
5553 push_member_name (constructor_unfilled_fields);
5554 warning_init ("missing initializer");
5555 RESTORE_SPELLING_DEPTH (constructor_depth);
5558 /* Now output all pending elements. */
5559 output_pending_init_elements (1);
5561 #if 0 /* c-parse.in warns about {}. */
5562 /* In ANSI, each brace level must have at least one element. */
5563 if (! implicit && pedantic
5564 && (TREE_CODE (constructor_type) == ARRAY_TYPE
5565 ? integer_zerop (constructor_unfilled_index)
5566 : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
5567 pedwarn_init ("empty braces in initializer");
5570 /* Pad out the end of the structure. */
5572 if (p->replacement_value)
5574 /* If this closes a superfluous brace pair,
5575 just pass out the element between them. */
5576 constructor = p->replacement_value;
5577 /* If this is the top level thing within the initializer,
5578 and it's for a variable, then since we already called
5579 assemble_variable, we must output the value now. */
5580 if (p->next == 0 && constructor_decl != 0
5581 && constructor_incremental)
5583 constructor = digest_init (constructor_type, constructor,
5584 require_constant_value,
5585 require_constant_elements);
5587 /* If initializing an array of unknown size,
5588 determine the size now. */
5589 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5590 && TYPE_DOMAIN (constructor_type) == 0)
5595 push_obstacks_nochange ();
5596 if (TREE_PERMANENT (constructor_type))
5597 end_temporary_allocation ();
5599 momentary_p = suspend_momentary ();
5601 /* We shouldn't have an incomplete array type within
5603 if (constructor_stack->next)
5607 = complete_array_type (constructor_type,
5612 size = int_size_in_bytes (constructor_type);
5613 resume_momentary (momentary_p);
5617 output_constant (constructor, size);
5620 else if (constructor_type == 0)
5622 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5623 && TREE_CODE (constructor_type) != UNION_TYPE
5624 && TREE_CODE (constructor_type) != ARRAY_TYPE
5625 && ! constructor_incremental)
5627 /* A nonincremental scalar initializer--just return
5628 the element, after verifying there is just one. */
5629 if (constructor_elements == 0)
5631 error_init ("empty scalar initializer");
5632 constructor = error_mark_node;
5634 else if (TREE_CHAIN (constructor_elements) != 0)
5636 error_init ("extra elements in scalar initializer");
5637 constructor = TREE_VALUE (constructor_elements);
5640 constructor = TREE_VALUE (constructor_elements);
5642 else if (! constructor_incremental)
5644 if (constructor_erroneous)
5645 constructor = error_mark_node;
5648 int momentary = suspend_momentary ();
5650 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5651 nreverse (constructor_elements));
5652 if (constructor_constant)
5653 TREE_CONSTANT (constructor) = 1;
5654 if (constructor_constant && constructor_simple)
5655 TREE_STATIC (constructor) = 1;
5657 resume_momentary (momentary);
5663 int momentary = suspend_momentary ();
5665 if (TREE_CODE (constructor_type) == RECORD_TYPE
5666 || TREE_CODE (constructor_type) == UNION_TYPE)
5668 /* Find the offset of the end of that field. */
5669 filled = size_binop (CEIL_DIV_EXPR,
5670 constructor_bit_index,
5671 size_int (BITS_PER_UNIT));
5673 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5675 /* If initializing an array of unknown size,
5676 determine the size now. */
5677 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5678 && TYPE_DOMAIN (constructor_type) == 0)
5681 = size_binop (MINUS_EXPR,
5682 constructor_unfilled_index,
5685 push_obstacks_nochange ();
5686 if (TREE_PERMANENT (constructor_type))
5687 end_temporary_allocation ();
5688 maxindex = copy_node (maxindex);
5689 TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5690 TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5692 /* TYPE_MAX_VALUE is always one less than the number of elements
5693 in the array, because we start counting at zero. Therefore,
5694 warn only if the value is less than zero. */
5696 && (tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5698 error_with_decl (constructor_decl,
5699 "zero or negative array size `%s'");
5700 layout_type (constructor_type);
5701 size = int_size_in_bytes (constructor_type);
5705 filled = size_binop (MULT_EXPR, constructor_unfilled_index,
5706 size_in_bytes (TREE_TYPE (constructor_type)));
5712 assemble_zeros (size - TREE_INT_CST_LOW (filled));
5714 resume_momentary (momentary);
5718 constructor_type = p->type;
5719 constructor_fields = p->fields;
5720 constructor_index = p->index;
5721 constructor_range_end = p->range_end;
5722 constructor_max_index = p->max_index;
5723 constructor_unfilled_index = p->unfilled_index;
5724 constructor_unfilled_fields = p->unfilled_fields;
5725 constructor_bit_index = p->bit_index;
5726 constructor_elements = p->elements;
5727 constructor_constant = p->constant;
5728 constructor_simple = p->simple;
5729 constructor_erroneous = p->erroneous;
5730 constructor_pending_elts = p->pending_elts;
5731 constructor_depth = p->depth;
5732 constructor_incremental = p->incremental;
5733 RESTORE_SPELLING_DEPTH (constructor_depth);
5735 constructor_stack = p->next;
5738 if (constructor == 0)
5740 if (constructor_stack == 0)
5741 return error_mark_node;
5747 /* Within an array initializer, specify the next index to be initialized.
5748 FIRST is that index. If LAST is nonzero, then initialize a range
5749 of indices, running from FIRST through LAST. */
5752 set_init_index (first, last)
5755 while ((TREE_CODE (first) == NOP_EXPR
5756 || TREE_CODE (first) == CONVERT_EXPR
5757 || TREE_CODE (first) == NON_LVALUE_EXPR)
5758 && (TYPE_MODE (TREE_TYPE (first))
5759 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5760 (first) = TREE_OPERAND (first, 0);
5762 while ((TREE_CODE (last) == NOP_EXPR
5763 || TREE_CODE (last) == CONVERT_EXPR
5764 || TREE_CODE (last) == NON_LVALUE_EXPR)
5765 && (TYPE_MODE (TREE_TYPE (last))
5766 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5767 (last) = TREE_OPERAND (last, 0);
5769 if (TREE_CODE (first) != INTEGER_CST)
5770 error_init ("nonconstant array index in initializer");
5771 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5772 error_init ("nonconstant array index in initializer");
5773 else if (! constructor_unfilled_index)
5774 error_init ("array index in non-array initializer");
5775 else if (tree_int_cst_lt (first, constructor_unfilled_index))
5776 error_init ("duplicate array index in initializer");
5779 TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (first);
5780 TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (first);
5782 if (last != 0 && tree_int_cst_lt (last, first))
5783 error_init ("empty index range in initializer");
5787 pedwarn ("ANSI C forbids specifying element to initialize");
5788 constructor_range_end = last;
5793 /* Within a struct initializer, specify the next field to be initialized. */
5796 set_init_label (fieldname)
5802 /* Don't die if an entire brace-pair level is superfluous
5803 in the containing level. */
5804 if (constructor_type == 0)
5807 for (tail = TYPE_FIELDS (constructor_type); tail;
5808 tail = TREE_CHAIN (tail))
5810 if (tail == constructor_unfilled_fields)
5812 if (DECL_NAME (tail) == fieldname)
5817 error ("unknown field `%s' specified in initializer",
5818 IDENTIFIER_POINTER (fieldname));
5820 error ("field `%s' already initialized",
5821 IDENTIFIER_POINTER (fieldname));
5824 constructor_fields = tail;
5826 pedwarn ("ANSI C forbids specifying structure member to initialize");
5830 /* Add a new initializer to the tree of pending initializers. PURPOSE
5831 indentifies the initializer, either array index or field in a structure.
5832 VALUE is the value of that index or field. */
5835 add_pending_init (purpose, value)
5836 tree purpose, value;
5838 struct init_node *p, **q, *r;
5840 q = &constructor_pending_elts;
5843 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5848 if (tree_int_cst_lt (purpose, p->purpose))
5850 else if (p->purpose != purpose)
5861 if (tree_int_cst_lt (DECL_FIELD_BITPOS (purpose),
5862 DECL_FIELD_BITPOS (p->purpose)))
5864 else if (p->purpose != purpose)
5871 r = (struct init_node *) oballoc (sizeof (struct init_node));
5872 r->purpose = purpose;
5883 struct init_node *s;
5887 if (p->balance == 0)
5889 else if (p->balance < 0)
5896 p->left->parent = p;
5913 constructor_pending_elts = r;
5918 struct init_node *t = r->right;
5922 r->right->parent = r;
5927 p->left->parent = p;
5930 p->balance = t->balance < 0;
5931 r->balance = -(t->balance > 0);
5946 constructor_pending_elts = t;
5952 /* p->balance == +1; growth of left side balances the node. */
5957 else /* r == p->right */
5959 if (p->balance == 0)
5960 /* Growth propagation from right side. */
5962 else if (p->balance > 0)
5969 p->right->parent = p;
5986 constructor_pending_elts = r;
5988 else /* r->balance == -1 */
5991 struct init_node *t = r->left;
5995 r->left->parent = r;
6000 p->right->parent = p;
6003 r->balance = (t->balance < 0);
6004 p->balance = -(t->balance > 0);
6019 constructor_pending_elts = t;
6025 /* p->balance == -1; growth of right side balances the node. */
6036 /* Return nonzero if FIELD is equal to the index of a pending initializer. */
6039 pending_init_member (field)
6042 struct init_node *p;
6044 p = constructor_pending_elts;
6045 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6049 if (field == p->purpose)
6051 else if (tree_int_cst_lt (field, p->purpose))
6061 if (field == p->purpose)
6063 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (field),
6064 DECL_FIELD_BITPOS (p->purpose)))
6074 /* "Output" the next constructor element.
6075 At top level, really output it to assembler code now.
6076 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6077 TYPE is the data type that the containing data type wants here.
6078 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6080 PENDING if non-nil means output pending elements that belong
6081 right after this element. (PENDING is normally 1;
6082 it is 0 while outputting pending elements, to avoid recursion.) */
6085 output_init_element (value, type, field, pending)
6086 tree value, type, field;
6091 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6092 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6093 && !(TREE_CODE (value) == STRING_CST
6094 && TREE_CODE (type) == ARRAY_TYPE
6095 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6096 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6097 TYPE_MAIN_VARIANT (type))))
6098 value = default_conversion (value);
6100 if (value == error_mark_node)
6101 constructor_erroneous = 1;
6102 else if (!TREE_CONSTANT (value))
6103 constructor_constant = 0;
6104 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6105 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6106 || TREE_CODE (constructor_type) == UNION_TYPE)
6107 && DECL_C_BIT_FIELD (field)
6108 && TREE_CODE (value) != INTEGER_CST))
6109 constructor_simple = 0;
6111 if (require_constant_value && ! TREE_CONSTANT (value))
6113 error_init ("initializer element is not constant");
6114 value = error_mark_node;
6116 else if (require_constant_elements
6117 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6119 error_init ("initializer element is not computable at load time");
6120 value = error_mark_node;
6123 /* If this element duplicates one on constructor_pending_elts,
6124 print a message and ignore it. Don't do this when we're
6125 processing elements taken off constructor_pending_elts,
6126 because we'd always get spurious errors. */
6129 if (TREE_CODE (constructor_type) == RECORD_TYPE
6130 || TREE_CODE (constructor_type) == UNION_TYPE
6131 || TREE_CODE (constructor_type) == ARRAY_TYPE)
6133 if (pending_init_member (field))
6135 error_init ("duplicate initializer");
6141 /* If this element doesn't come next in sequence,
6142 put it on constructor_pending_elts. */
6143 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6144 && !tree_int_cst_equal (field, constructor_unfilled_index))
6147 /* The copy_node is needed in case field is actually
6148 constructor_index, which is modified in place. */
6149 add_pending_init (copy_node (field),
6150 digest_init (type, value, require_constant_value,
6151 require_constant_elements));
6153 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6154 && field != constructor_unfilled_fields)
6156 /* We do this for records but not for unions. In a union,
6157 no matter which field is specified, it can be initialized
6158 right away since it starts at the beginning of the union. */
6160 add_pending_init (field,
6161 digest_init (type, value, require_constant_value,
6162 require_constant_elements));
6166 /* Otherwise, output this element either to
6167 constructor_elements or to the assembler file. */
6171 if (! constructor_incremental)
6173 if (field && TREE_CODE (field) == INTEGER_CST)
6174 field = copy_node (field);
6175 constructor_elements
6176 = tree_cons (field, digest_init (type, value,
6177 require_constant_value,
6178 require_constant_elements),
6179 constructor_elements);
6183 /* Structure elements may require alignment.
6184 Do this, if necessary. */
6185 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6187 /* Advance to offset of this element. */
6188 if (! tree_int_cst_equal (constructor_bit_index,
6189 DECL_FIELD_BITPOS (field)))
6191 /* By using unsigned arithmetic, the result will be
6192 correct even in case of overflows, if BITS_PER_UNIT
6193 is a power of two. */
6194 unsigned next = (TREE_INT_CST_LOW
6195 (DECL_FIELD_BITPOS (field))
6196 / (unsigned)BITS_PER_UNIT);
6197 unsigned here = (TREE_INT_CST_LOW
6198 (constructor_bit_index)
6199 / (unsigned)BITS_PER_UNIT);
6201 assemble_zeros ((next - here)
6202 * (unsigned)BITS_PER_UNIT
6203 / (unsigned)BITS_PER_UNIT);
6206 output_constant (digest_init (type, value,
6207 require_constant_value,
6208 require_constant_elements),
6209 int_size_in_bytes (type));
6211 /* For a record or union,
6212 keep track of end position of last field. */
6213 if (TREE_CODE (constructor_type) == RECORD_TYPE
6214 || TREE_CODE (constructor_type) == UNION_TYPE)
6216 tree temp = size_binop (PLUS_EXPR, DECL_FIELD_BITPOS (field),
6218 TREE_INT_CST_LOW (constructor_bit_index)
6219 = TREE_INT_CST_LOW (temp);
6220 TREE_INT_CST_HIGH (constructor_bit_index)
6221 = TREE_INT_CST_HIGH (temp);
6226 /* Advance the variable that indicates sequential elements output. */
6227 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6229 tree tem = size_binop (PLUS_EXPR, constructor_unfilled_index,
6231 TREE_INT_CST_LOW (constructor_unfilled_index)
6232 = TREE_INT_CST_LOW (tem);
6233 TREE_INT_CST_HIGH (constructor_unfilled_index)
6234 = TREE_INT_CST_HIGH (tem);
6236 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6237 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6238 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6239 constructor_unfilled_fields = 0;
6241 /* Now output any pending elements which have become next. */
6243 output_pending_init_elements (0);
6247 /* Output any pending elements which have become next.
6248 As we output elements, constructor_unfilled_{fields,index}
6249 advances, which may cause other elements to become next;
6250 if so, they too are output.
6252 If ALL is 0, we return when there are
6253 no more pending elements to output now.
6255 If ALL is 1, we output space as necessary so that
6256 we can output all the pending elements. */
6259 output_pending_init_elements (all)
6262 struct init_node *elt = constructor_pending_elts;
6267 /* Look thru the whole pending tree.
6268 If we find an element that should be output now,
6269 output it. Otherwise, set NEXT to the element
6270 that comes first among those still pending. */
6275 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6277 if (tree_int_cst_equal (elt->purpose,
6278 constructor_unfilled_index))
6279 output_init_element (elt->value,
6280 TREE_TYPE (constructor_type),
6281 constructor_unfilled_index, 0);
6282 else if (tree_int_cst_lt (constructor_unfilled_index,
6285 /* Advance to the next smaller node. */
6290 /* We have reached the smallest node bigger than the
6291 current unfilled index. Fill the space first. */
6292 next = elt->purpose;
6298 /* Advance to the next bigger node. */
6303 /* We have reached the biggest node in a subtree. Find
6304 the parent of it, which is the next bigger node. */
6305 while (elt->parent && elt->parent->right == elt)
6308 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6311 next = elt->purpose;
6317 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6318 || TREE_CODE (constructor_type) == UNION_TYPE)
6320 /* If the current record is complete we are done. */
6321 if (constructor_unfilled_fields == 0)
6323 if (elt->purpose == constructor_unfilled_fields)
6325 output_init_element (elt->value,
6326 TREE_TYPE (constructor_unfilled_fields),
6327 constructor_unfilled_fields,
6330 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6331 DECL_FIELD_BITPOS (elt->purpose)))
6333 /* Advance to the next smaller node. */
6338 /* We have reached the smallest node bigger than the
6339 current unfilled field. Fill the space first. */
6340 next = elt->purpose;
6346 /* Advance to the next bigger node. */
6351 /* We have reached the biggest node in a subtree. Find
6352 the parent of it, which is the next bigger node. */
6353 while (elt->parent && elt->parent->right == elt)
6357 && tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6358 DECL_FIELD_BITPOS (elt->purpose)))
6360 next = elt->purpose;
6368 /* Ordinarily return, but not if we want to output all
6369 and there are elements left. */
6370 if (! (all && next != 0))
6373 /* Generate space up to the position of NEXT. */
6374 if (constructor_incremental)
6377 tree nextpos_tree = size_int (0);
6379 if (TREE_CODE (constructor_type) == RECORD_TYPE
6380 || TREE_CODE (constructor_type) == UNION_TYPE)
6383 /* Find the last field written out, if any. */
6384 for (tail = TYPE_FIELDS (constructor_type); tail;
6385 tail = TREE_CHAIN (tail))
6386 if (TREE_CHAIN (tail) == constructor_unfilled_fields)
6390 /* Find the offset of the end of that field. */
6391 filled = size_binop (CEIL_DIV_EXPR,
6392 size_binop (PLUS_EXPR,
6393 DECL_FIELD_BITPOS (tail),
6395 size_int (BITS_PER_UNIT));
6397 filled = size_int (0);
6399 nextpos_tree = size_binop (CEIL_DIV_EXPR,
6400 DECL_FIELD_BITPOS (next),
6401 size_int (BITS_PER_UNIT));
6403 TREE_INT_CST_HIGH (constructor_bit_index)
6404 = TREE_INT_CST_HIGH (DECL_FIELD_BITPOS (next));
6405 TREE_INT_CST_LOW (constructor_bit_index)
6406 = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (next));
6407 constructor_unfilled_fields = next;
6409 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6411 filled = size_binop (MULT_EXPR, constructor_unfilled_index,
6412 size_in_bytes (TREE_TYPE (constructor_type)));
6414 = size_binop (MULT_EXPR, next,
6415 size_in_bytes (TREE_TYPE (constructor_type)));
6416 TREE_INT_CST_LOW (constructor_unfilled_index)
6417 = TREE_INT_CST_LOW (next);
6418 TREE_INT_CST_HIGH (constructor_unfilled_index)
6419 = TREE_INT_CST_HIGH (next);
6426 int nextpos = TREE_INT_CST_LOW (nextpos_tree);
6428 assemble_zeros (nextpos - TREE_INT_CST_LOW (filled));
6433 /* If it's not incremental, just skip over the gap,
6434 so that after jumping to retry we will output the next
6435 successive element. */
6436 if (TREE_CODE (constructor_type) == RECORD_TYPE
6437 || TREE_CODE (constructor_type) == UNION_TYPE)
6438 constructor_unfilled_fields = next;
6439 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6441 TREE_INT_CST_LOW (constructor_unfilled_index)
6442 = TREE_INT_CST_LOW (next);
6443 TREE_INT_CST_HIGH (constructor_unfilled_index)
6444 = TREE_INT_CST_HIGH (next);
6448 /* ELT now points to the node in the pending tree with the next
6449 initializer to output. */
6453 /* Add one non-braced element to the current constructor level.
6454 This adjusts the current position within the constructor's type.
6455 This may also start or terminate implicit levels
6456 to handle a partly-braced initializer.
6458 Once this has found the correct level for the new element,
6459 it calls output_init_element.
6461 Note: if we are incrementally outputting this constructor,
6462 this function may be called with a null argument
6463 representing a sub-constructor that was already incrementally output.
6464 When that happens, we output nothing, but we do the bookkeeping
6465 to skip past that element of the current constructor. */
6468 process_init_element (value)
6471 tree orig_value = value;
6472 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6474 /* Handle superfluous braces around string cst as in
6475 char x[] = {"foo"}; */
6478 && TREE_CODE (constructor_type) == ARRAY_TYPE
6479 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6480 && integer_zerop (constructor_unfilled_index))
6482 constructor_stack->replacement_value = value;
6486 if (constructor_stack->replacement_value != 0)
6488 error_init ("excess elements in struct initializer");
6492 /* Ignore elements of a brace group if it is entirely superfluous
6493 and has already been diagnosed. */
6494 if (constructor_type == 0)
6497 /* If we've exhausted any levels that didn't have braces,
6499 while (constructor_stack->implicit)
6501 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6502 || TREE_CODE (constructor_type) == UNION_TYPE)
6503 && constructor_fields == 0)
6504 process_init_element (pop_init_level (1));
6505 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6506 && (constructor_max_index == 0
6507 || tree_int_cst_lt (constructor_max_index,
6508 constructor_index)))
6509 process_init_element (pop_init_level (1));
6516 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6519 enum tree_code fieldcode;
6521 if (constructor_fields == 0)
6523 pedwarn_init ("excess elements in struct initializer");
6527 fieldtype = TREE_TYPE (constructor_fields);
6528 if (fieldtype != error_mark_node)
6529 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6530 fieldcode = TREE_CODE (fieldtype);
6532 /* Accept a string constant to initialize a subarray. */
6534 && fieldcode == ARRAY_TYPE
6535 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6538 /* Otherwise, if we have come to a subaggregate,
6539 and we don't have an element of its type, push into it. */
6540 else if (value != 0 && !constructor_no_implicit
6541 && value != error_mark_node
6542 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6543 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6544 || fieldcode == UNION_TYPE))
6546 push_init_level (1);
6552 push_member_name (constructor_fields);
6553 output_init_element (value, fieldtype, constructor_fields, 1);
6554 RESTORE_SPELLING_DEPTH (constructor_depth);
6557 /* Do the bookkeeping for an element that was
6558 directly output as a constructor. */
6560 /* For a record, keep track of end position of last field. */
6561 tree temp = size_binop (PLUS_EXPR,
6562 DECL_FIELD_BITPOS (constructor_fields),
6563 DECL_SIZE (constructor_fields));
6564 TREE_INT_CST_LOW (constructor_bit_index)
6565 = TREE_INT_CST_LOW (temp);
6566 TREE_INT_CST_HIGH (constructor_bit_index)
6567 = TREE_INT_CST_HIGH (temp);
6569 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6572 constructor_fields = TREE_CHAIN (constructor_fields);
6573 /* Skip any nameless bit fields at the beginning. */
6574 while (constructor_fields != 0
6575 && DECL_C_BIT_FIELD (constructor_fields)
6576 && DECL_NAME (constructor_fields) == 0)
6577 constructor_fields = TREE_CHAIN (constructor_fields);
6580 if (TREE_CODE (constructor_type) == UNION_TYPE)
6583 enum tree_code fieldcode;
6585 if (constructor_fields == 0)
6587 pedwarn_init ("excess elements in union initializer");
6591 fieldtype = TREE_TYPE (constructor_fields);
6592 if (fieldtype != error_mark_node)
6593 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6594 fieldcode = TREE_CODE (fieldtype);
6596 /* Accept a string constant to initialize a subarray. */
6598 && fieldcode == ARRAY_TYPE
6599 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6602 /* Otherwise, if we have come to a subaggregate,
6603 and we don't have an element of its type, push into it. */
6604 else if (value != 0 && !constructor_no_implicit
6605 && value != error_mark_node
6606 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6607 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6608 || fieldcode == UNION_TYPE))
6610 push_init_level (1);
6616 push_member_name (constructor_fields);
6617 output_init_element (value, fieldtype, constructor_fields, 1);
6618 RESTORE_SPELLING_DEPTH (constructor_depth);
6621 /* Do the bookkeeping for an element that was
6622 directly output as a constructor. */
6624 TREE_INT_CST_LOW (constructor_bit_index)
6625 = TREE_INT_CST_LOW (DECL_SIZE (constructor_fields));
6626 TREE_INT_CST_HIGH (constructor_bit_index)
6627 = TREE_INT_CST_HIGH (DECL_SIZE (constructor_fields));
6629 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6632 constructor_fields = 0;
6635 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6637 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6638 enum tree_code eltcode = TREE_CODE (elttype);
6640 /* Accept a string constant to initialize a subarray. */
6642 && eltcode == ARRAY_TYPE
6643 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6646 /* Otherwise, if we have come to a subaggregate,
6647 and we don't have an element of its type, push into it. */
6648 else if (value != 0 && !constructor_no_implicit
6649 && value != error_mark_node
6650 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6651 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6652 || eltcode == UNION_TYPE))
6654 push_init_level (1);
6658 if (constructor_max_index != 0
6659 && tree_int_cst_lt (constructor_max_index, constructor_index))
6661 pedwarn_init ("excess elements in array initializer");
6665 /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once. */
6666 if (constructor_range_end)
6668 if (constructor_max_index != 0
6669 && tree_int_cst_lt (constructor_max_index,
6670 constructor_range_end))
6672 pedwarn_init ("excess elements in array initializer");
6673 TREE_INT_CST_HIGH (constructor_range_end)
6674 = TREE_INT_CST_HIGH (constructor_max_index);
6675 TREE_INT_CST_LOW (constructor_range_end)
6676 = TREE_INT_CST_LOW (constructor_max_index);
6679 value = save_expr (value);
6682 /* Now output the actual element.
6683 Ordinarily, output once.
6684 If there is a range, repeat it till we advance past the range. */
6691 push_array_bounds (TREE_INT_CST_LOW (constructor_index));
6692 output_init_element (value, elttype, constructor_index, 1);
6693 RESTORE_SPELLING_DEPTH (constructor_depth);
6696 tem = size_binop (PLUS_EXPR, constructor_index,
6698 TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (tem);
6699 TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (tem);
6702 /* If we are doing the bookkeeping for an element that was
6703 directly output as a constructor,
6704 we must update constructor_unfilled_index. */
6706 TREE_INT_CST_LOW (constructor_unfilled_index)
6707 = TREE_INT_CST_LOW (constructor_index);
6708 TREE_INT_CST_HIGH (constructor_unfilled_index)
6709 = TREE_INT_CST_HIGH (constructor_index);
6712 while (! (constructor_range_end == 0
6713 || tree_int_cst_lt (constructor_range_end,
6714 constructor_index)));
6719 /* Handle the sole element allowed in a braced initializer
6720 for a scalar variable. */
6721 if (constructor_fields == 0)
6723 pedwarn_init ("excess elements in scalar initializer");
6728 output_init_element (value, constructor_type, NULL_TREE, 1);
6729 constructor_fields = 0;
6733 /* If the (lexically) previous elments are not now saved,
6734 we can discard the storage for them. */
6735 if (constructor_incremental && constructor_pending_elts == 0 && value != 0
6736 && constructor_stack == 0)
6740 /* Expand an ASM statement with operands, handling output operands
6741 that are not variables or INDIRECT_REFS by transforming such
6742 cases into cases that expand_asm_operands can handle.
6744 Arguments are same as for expand_asm_operands. */
6747 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6748 tree string, outputs, inputs, clobbers;
6753 int noutputs = list_length (outputs);
6755 /* o[I] is the place that output number I should be written. */
6756 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6759 if (TREE_CODE (string) == ADDR_EXPR)
6760 string = TREE_OPERAND (string, 0);
6761 if (TREE_CODE (string) != STRING_CST)
6763 error ("asm template is not a string constant");
6767 /* Record the contents of OUTPUTS before it is modified. */
6768 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6769 o[i] = TREE_VALUE (tail);
6771 /* Perform default conversions on array and function inputs. */
6772 /* Don't do this for other types--
6773 it would screw up operands expected to be in memory. */
6774 for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6775 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6776 || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6777 TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6779 /* Generate the ASM_OPERANDS insn;
6780 store into the TREE_VALUEs of OUTPUTS some trees for
6781 where the values were actually stored. */
6782 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6784 /* Copy all the intermediate outputs into the specified outputs. */
6785 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6787 if (o[i] != TREE_VALUE (tail))
6789 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6790 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6793 /* Detect modification of read-only values.
6794 (Otherwise done by build_modify_expr.) */
6797 tree type = TREE_TYPE (o[i]);
6798 if (TREE_READONLY (o[i])
6799 || TYPE_READONLY (type)
6800 || ((TREE_CODE (type) == RECORD_TYPE
6801 || TREE_CODE (type) == UNION_TYPE)
6802 && C_TYPE_FIELDS_READONLY (type)))
6803 readonly_warning (o[i], "modification by `asm'");
6807 /* Those MODIFY_EXPRs could do autoincrements. */
6811 /* Expand a C `return' statement.
6812 RETVAL is the expression for what to return,
6813 or a null pointer for `return;' with no value. */
6816 c_expand_return (retval)
6819 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6821 if (TREE_THIS_VOLATILE (current_function_decl))
6822 warning ("function declared `noreturn' has a `return' statement");
6826 current_function_returns_null = 1;
6827 if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6828 warning ("`return' with no value, in function returning non-void");
6829 expand_null_return ();
6831 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6833 current_function_returns_null = 1;
6834 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6835 pedwarn ("`return' with a value, in function returning void");
6836 expand_return (retval);
6840 tree t = convert_for_assignment (valtype, retval, _("return"),
6841 NULL_TREE, NULL_TREE, 0);
6842 tree res = DECL_RESULT (current_function_decl);
6845 if (t == error_mark_node)
6848 inner = t = convert (TREE_TYPE (res), t);
6850 /* Strip any conversions, additions, and subtractions, and see if
6851 we are returning the address of a local variable. Warn if so. */
6854 switch (TREE_CODE (inner))
6856 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6858 inner = TREE_OPERAND (inner, 0);
6862 /* If the second operand of the MINUS_EXPR has a pointer
6863 type (or is converted from it), this may be valid, so
6864 don't give a warning. */
6866 tree op1 = TREE_OPERAND (inner, 1);
6868 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6869 && (TREE_CODE (op1) == NOP_EXPR
6870 || TREE_CODE (op1) == NON_LVALUE_EXPR
6871 || TREE_CODE (op1) == CONVERT_EXPR))
6872 op1 = TREE_OPERAND (op1, 0);
6874 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6877 inner = TREE_OPERAND (inner, 0);
6882 inner = TREE_OPERAND (inner, 0);
6884 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6885 inner = TREE_OPERAND (inner, 0);
6887 if (TREE_CODE (inner) == VAR_DECL
6888 && ! DECL_EXTERNAL (inner)
6889 && ! TREE_STATIC (inner)
6890 && DECL_CONTEXT (inner) == current_function_decl)
6891 warning ("function returns address of local variable");
6901 t = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6902 TREE_SIDE_EFFECTS (t) = 1;
6904 current_function_returns_value = 1;
6908 /* Start a C switch statement, testing expression EXP.
6909 Return EXP if it is valid, an error node otherwise. */
6912 c_expand_start_case (exp)
6915 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
6916 tree type = TREE_TYPE (exp);
6918 if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
6920 error ("switch quantity not an integer");
6921 exp = error_mark_node;
6926 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6928 if (warn_traditional
6929 && (type == long_integer_type_node
6930 || type == long_unsigned_type_node))
6931 pedwarn ("`long' switch expression not converted to `int' in ANSI C");
6933 exp = default_conversion (exp);
6934 type = TREE_TYPE (exp);
6935 index = get_unwidened (exp, NULL_TREE);
6936 /* We can't strip a conversion from a signed type to an unsigned,
6937 because if we did, int_fits_type_p would do the wrong thing
6938 when checking case values for being in range,
6939 and it's too hard to do the right thing. */
6940 if (TREE_UNSIGNED (TREE_TYPE (exp))
6941 == TREE_UNSIGNED (TREE_TYPE (index)))
6945 expand_start_case (1, exp, type, "switch statement");