1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This file is part of the C front end.
24 It contains routines to build C expressions given their operands,
25 including computing the types of the result, C-specific error checks,
26 and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
46 /* Nonzero if we've already printed a "missing braces around initializer"
47 message within this initializer. */
48 static int missing_braces_mentioned;
50 /* 1 if we explained undeclared var errors. */
51 static int undeclared_variable_notice;
53 static tree qualify_type PARAMS ((tree, tree));
54 static int comp_target_types PARAMS ((tree, tree));
55 static int function_types_compatible_p PARAMS ((tree, tree));
56 static int type_lists_compatible_p PARAMS ((tree, tree));
57 static tree decl_constant_value_for_broken_optimization PARAMS ((tree));
58 static tree default_function_array_conversion PARAMS ((tree));
59 static tree lookup_field PARAMS ((tree, tree));
60 static tree convert_arguments PARAMS ((tree, tree, tree, tree));
61 static tree pointer_int_sum PARAMS ((enum tree_code, tree, tree));
62 static tree pointer_diff PARAMS ((tree, tree));
63 static tree unary_complex_lvalue PARAMS ((enum tree_code, tree, int));
64 static void pedantic_lvalue_warning PARAMS ((enum tree_code));
65 static tree internal_build_compound_expr PARAMS ((tree, int));
66 static tree convert_for_assignment PARAMS ((tree, tree, const char *,
68 static void warn_for_assignment PARAMS ((const char *, const char *,
70 static tree valid_compound_expr_initializer PARAMS ((tree, tree));
71 static void push_string PARAMS ((const char *));
72 static void push_member_name PARAMS ((tree));
73 static void push_array_bounds PARAMS ((int));
74 static int spelling_length PARAMS ((void));
75 static char *print_spelling PARAMS ((char *));
76 static void warning_init PARAMS ((const char *));
77 static tree digest_init PARAMS ((tree, tree, int, int));
78 static void output_init_element PARAMS ((tree, tree, tree, int));
79 static void output_pending_init_elements PARAMS ((int));
80 static int set_designator PARAMS ((int));
81 static void push_range_stack PARAMS ((tree));
82 static void add_pending_init PARAMS ((tree, tree));
83 static void set_nonincremental_init PARAMS ((void));
84 static void set_nonincremental_init_from_string PARAMS ((tree));
85 static tree find_init_member PARAMS ((tree));
87 /* Do `exp = require_complete_type (exp);' to make sure exp
88 does not have an incomplete type. (That includes void types.) */
91 require_complete_type (value)
94 tree type = TREE_TYPE (value);
96 if (TREE_CODE (value) == ERROR_MARK)
97 return error_mark_node;
99 /* First, detect a valid value with a complete type. */
100 if (COMPLETE_TYPE_P (type))
103 incomplete_type_error (value, type);
104 return error_mark_node;
107 /* Print an error message for invalid use of an incomplete type.
108 VALUE is the expression that was used (or 0 if that isn't known)
109 and TYPE is the type that was invalid. */
112 incomplete_type_error (value, type)
116 const char *type_code_string;
118 /* Avoid duplicate error message. */
119 if (TREE_CODE (type) == ERROR_MARK)
122 if (value != 0 && (TREE_CODE (value) == VAR_DECL
123 || TREE_CODE (value) == PARM_DECL))
124 error ("`%s' has an incomplete type",
125 IDENTIFIER_POINTER (DECL_NAME (value)));
129 /* We must print an error message. Be clever about what it says. */
131 switch (TREE_CODE (type))
134 type_code_string = "struct";
138 type_code_string = "union";
142 type_code_string = "enum";
146 error ("invalid use of void expression");
150 if (TYPE_DOMAIN (type))
152 type = TREE_TYPE (type);
155 error ("invalid use of array with unspecified bounds");
162 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
163 error ("invalid use of undefined type `%s %s'",
164 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
166 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
167 error ("invalid use of incomplete typedef `%s'",
168 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
172 /* Return a variant of TYPE which has all the type qualifiers of LIKE
173 as well as those of TYPE. */
176 qualify_type (type, like)
179 return c_build_qualified_type (type,
180 TYPE_QUALS (type) | TYPE_QUALS (like));
183 /* Return the common type of two types.
184 We assume that comptypes has already been done and returned 1;
185 if that isn't so, this may crash. In particular, we assume that qualifiers
188 This is the type for the result of most arithmetic operations
189 if the operands have the given two types. */
195 enum tree_code code1;
196 enum tree_code code2;
199 /* Save time if the two types are the same. */
201 if (t1 == t2) return t1;
203 /* If one type is nonsense, use the other. */
204 if (t1 == error_mark_node)
206 if (t2 == error_mark_node)
209 /* Merge the attributes. */
210 attributes = (*targetm.merge_type_attributes) (t1, t2);
212 /* Treat an enum type as the unsigned integer type of the same width. */
214 if (TREE_CODE (t1) == ENUMERAL_TYPE)
215 t1 = type_for_size (TYPE_PRECISION (t1), 1);
216 if (TREE_CODE (t2) == ENUMERAL_TYPE)
217 t2 = type_for_size (TYPE_PRECISION (t2), 1);
219 code1 = TREE_CODE (t1);
220 code2 = TREE_CODE (t2);
222 /* If one type is complex, form the common type of the non-complex
223 components, then make that complex. Use T1 or T2 if it is the
225 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
227 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
228 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
229 tree subtype = common_type (subtype1, subtype2);
231 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
232 return build_type_attribute_variant (t1, attributes);
233 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
234 return build_type_attribute_variant (t2, attributes);
236 return build_type_attribute_variant (build_complex_type (subtype),
244 /* If only one is real, use it as the result. */
246 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
247 return build_type_attribute_variant (t1, attributes);
249 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
250 return build_type_attribute_variant (t2, attributes);
252 /* Both real or both integers; use the one with greater precision. */
254 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
255 return build_type_attribute_variant (t1, attributes);
256 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
257 return build_type_attribute_variant (t2, attributes);
259 /* Same precision. Prefer longs to ints even when same size. */
261 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
262 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
263 return build_type_attribute_variant (long_unsigned_type_node,
266 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
267 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
269 /* But preserve unsignedness from the other type,
270 since long cannot hold all the values of an unsigned int. */
271 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
272 t1 = long_unsigned_type_node;
274 t1 = long_integer_type_node;
275 return build_type_attribute_variant (t1, attributes);
278 /* Likewise, prefer long double to double even if same size. */
279 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
280 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
281 return build_type_attribute_variant (long_double_type_node,
284 /* Otherwise prefer the unsigned one. */
286 if (TREE_UNSIGNED (t1))
287 return build_type_attribute_variant (t1, attributes);
289 return build_type_attribute_variant (t2, attributes);
292 /* For two pointers, do this recursively on the target type,
293 and combine the qualifiers of the two types' targets. */
294 /* This code was turned off; I don't know why.
295 But ANSI C specifies doing this with the qualifiers.
296 So I turned it on again. */
298 tree pointed_to_1 = TREE_TYPE (t1);
299 tree pointed_to_2 = TREE_TYPE (t2);
300 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
301 TYPE_MAIN_VARIANT (pointed_to_2));
302 t1 = build_pointer_type (c_build_qualified_type
304 TYPE_QUALS (pointed_to_1) |
305 TYPE_QUALS (pointed_to_2)));
306 return build_type_attribute_variant (t1, attributes);
309 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
310 return build_type_attribute_variant (t1, attributes);
315 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
316 /* Save space: see if the result is identical to one of the args. */
317 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
318 return build_type_attribute_variant (t1, attributes);
319 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
320 return build_type_attribute_variant (t2, attributes);
321 /* Merge the element types, and have a size if either arg has one. */
322 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
323 return build_type_attribute_variant (t1, attributes);
327 /* Function types: prefer the one that specified arg types.
328 If both do, merge the arg types. Also merge the return types. */
330 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
331 tree p1 = TYPE_ARG_TYPES (t1);
332 tree p2 = TYPE_ARG_TYPES (t2);
337 /* Save space: see if the result is identical to one of the args. */
338 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
339 return build_type_attribute_variant (t1, attributes);
340 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
341 return build_type_attribute_variant (t2, attributes);
343 /* Simple way if one arg fails to specify argument types. */
344 if (TYPE_ARG_TYPES (t1) == 0)
346 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
347 return build_type_attribute_variant (t1, attributes);
349 if (TYPE_ARG_TYPES (t2) == 0)
351 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
352 return build_type_attribute_variant (t1, attributes);
355 /* If both args specify argument types, we must merge the two
356 lists, argument by argument. */
359 declare_parm_level (1);
361 len = list_length (p1);
364 for (i = 0; i < len; i++)
365 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
370 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
372 /* A null type means arg type is not specified.
373 Take whatever the other function type has. */
374 if (TREE_VALUE (p1) == 0)
376 TREE_VALUE (n) = TREE_VALUE (p2);
379 if (TREE_VALUE (p2) == 0)
381 TREE_VALUE (n) = TREE_VALUE (p1);
385 /* Given wait (union {union wait *u; int *i} *)
386 and wait (union wait *),
387 prefer union wait * as type of parm. */
388 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
389 && TREE_VALUE (p1) != TREE_VALUE (p2))
392 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
393 memb; memb = TREE_CHAIN (memb))
394 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
396 TREE_VALUE (n) = TREE_VALUE (p2);
398 pedwarn ("function types not truly compatible in ISO C");
402 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
403 && TREE_VALUE (p2) != TREE_VALUE (p1))
406 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
407 memb; memb = TREE_CHAIN (memb))
408 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
410 TREE_VALUE (n) = TREE_VALUE (p1);
412 pedwarn ("function types not truly compatible in ISO C");
416 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
422 t1 = build_function_type (valtype, newargs);
423 /* ... falls through ... */
427 return build_type_attribute_variant (t1, attributes);
432 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
433 or various other operations. Return 2 if they are compatible
434 but a warning may be needed if you use them together. */
437 comptypes (type1, type2)
444 /* Suppress errors caused by previously reported errors. */
446 if (t1 == t2 || !t1 || !t2
447 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
450 /* If either type is the internal version of sizetype, return the
452 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
453 && TYPE_DOMAIN (t1) != 0)
454 t1 = TYPE_DOMAIN (t1);
456 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
457 && TYPE_DOMAIN (t2) != 0)
458 t2 = TYPE_DOMAIN (t2);
460 /* Treat an enum type as the integer type of the same width and
463 if (TREE_CODE (t1) == ENUMERAL_TYPE)
464 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
465 if (TREE_CODE (t2) == ENUMERAL_TYPE)
466 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
471 /* Different classes of types can't be compatible. */
473 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
475 /* Qualifiers must match. */
477 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
480 /* Allow for two different type nodes which have essentially the same
481 definition. Note that we already checked for equality of the type
482 qualifiers (just above). */
484 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
487 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
488 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
491 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
494 switch (TREE_CODE (t1))
497 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
498 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
502 val = function_types_compatible_p (t1, t2);
507 tree d1 = TYPE_DOMAIN (t1);
508 tree d2 = TYPE_DOMAIN (t2);
509 bool d1_variable, d2_variable;
510 bool d1_zero, d2_zero;
513 /* Target types must match incl. qualifiers. */
514 if (TREE_TYPE (t1) != TREE_TYPE (t2)
515 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
518 /* Sizes must match unless one is missing or variable. */
519 if (d1 == 0 || d2 == 0 || d1 == d2)
522 d1_zero = ! TYPE_MAX_VALUE (d1);
523 d2_zero = ! TYPE_MAX_VALUE (d2);
525 d1_variable = (! d1_zero
526 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
527 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
528 d2_variable = (! d2_zero
529 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
530 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
532 if (d1_variable || d2_variable)
534 if (d1_zero && d2_zero)
536 if (d1_zero || d2_zero
537 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
538 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
545 if (maybe_objc_comptypes (t1, t2, 0) == 1)
552 return attrval == 2 && val == 1 ? 2 : val;
555 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
556 ignoring their qualifiers. */
559 comp_target_types (ttl, ttr)
564 /* Give maybe_objc_comptypes a crack at letting these types through. */
565 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
568 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
569 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
571 if (val == 2 && pedantic)
572 pedwarn ("types are not quite compatible");
576 /* Subroutines of `comptypes'. */
578 /* Return 1 if two function types F1 and F2 are compatible.
579 If either type specifies no argument types,
580 the other must specify a fixed number of self-promoting arg types.
581 Otherwise, if one type specifies only the number of arguments,
582 the other must specify that number of self-promoting arg types.
583 Otherwise, the argument types must match. */
586 function_types_compatible_p (f1, f2)
590 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
594 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
595 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
598 args1 = TYPE_ARG_TYPES (f1);
599 args2 = TYPE_ARG_TYPES (f2);
601 /* An unspecified parmlist matches any specified parmlist
602 whose argument types don't need default promotions. */
606 if (!self_promoting_args_p (args2))
608 /* If one of these types comes from a non-prototype fn definition,
609 compare that with the other type's arglist.
610 If they don't match, ask for a warning (but no error). */
611 if (TYPE_ACTUAL_ARG_TYPES (f1)
612 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
618 if (!self_promoting_args_p (args1))
620 if (TYPE_ACTUAL_ARG_TYPES (f2)
621 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
626 /* Both types have argument lists: compare them and propagate results. */
627 val1 = type_lists_compatible_p (args1, args2);
628 return val1 != 1 ? val1 : val;
631 /* Check two lists of types for compatibility,
632 returning 0 for incompatible, 1 for compatible,
633 or 2 for compatible with warning. */
636 type_lists_compatible_p (args1, args2)
639 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
645 if (args1 == 0 && args2 == 0)
647 /* If one list is shorter than the other,
648 they fail to match. */
649 if (args1 == 0 || args2 == 0)
651 /* A null pointer instead of a type
652 means there is supposed to be an argument
653 but nothing is specified about what type it has.
654 So match anything that self-promotes. */
655 if (TREE_VALUE (args1) == 0)
657 if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE)
660 else if (TREE_VALUE (args2) == 0)
662 if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE)
665 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
666 TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
668 /* Allow wait (union {union wait *u; int *i} *)
669 and wait (union wait *) to be compatible. */
670 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
671 && (TYPE_NAME (TREE_VALUE (args1)) == 0
672 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
673 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
674 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
675 TYPE_SIZE (TREE_VALUE (args2))))
678 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
679 memb; memb = TREE_CHAIN (memb))
680 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
685 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
686 && (TYPE_NAME (TREE_VALUE (args2)) == 0
687 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
688 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
689 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
690 TYPE_SIZE (TREE_VALUE (args1))))
693 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
694 memb; memb = TREE_CHAIN (memb))
695 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
704 /* comptypes said ok, but record if it said to warn. */
708 args1 = TREE_CHAIN (args1);
709 args2 = TREE_CHAIN (args2);
713 /* Compute the value of the `sizeof' operator. */
719 enum tree_code code = TREE_CODE (type);
722 if (code == FUNCTION_TYPE)
724 if (pedantic || warn_pointer_arith)
725 pedwarn ("sizeof applied to a function type");
726 size = size_one_node;
728 else if (code == VOID_TYPE)
730 if (pedantic || warn_pointer_arith)
731 pedwarn ("sizeof applied to a void type");
732 size = size_one_node;
734 else if (code == ERROR_MARK)
735 size = size_one_node;
736 else if (!COMPLETE_TYPE_P (type))
738 error ("sizeof applied to an incomplete type");
739 size = size_zero_node;
742 /* Convert in case a char is more than one unit. */
743 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
744 size_int (TYPE_PRECISION (char_type_node)
747 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
748 TYPE_IS_SIZETYPE means that certain things (like overflow) will
749 never happen. However, this node should really have type
750 `size_t', which is just a typedef for an ordinary integer type. */
751 return fold (build1 (NOP_EXPR, c_size_type_node, size));
755 c_sizeof_nowarn (type)
758 enum tree_code code = TREE_CODE (type);
761 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
762 size = size_one_node;
763 else if (!COMPLETE_TYPE_P (type))
764 size = size_zero_node;
766 /* Convert in case a char is more than one unit. */
767 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
768 size_int (TYPE_PRECISION (char_type_node)
771 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
772 TYPE_IS_SIZETYPE means that certain things (like overflow) will
773 never happen. However, this node should really have type
774 `size_t', which is just a typedef for an ordinary integer type. */
775 return fold (build1 (NOP_EXPR, c_size_type_node, size));
778 /* Compute the size to increment a pointer by. */
781 c_size_in_bytes (type)
784 enum tree_code code = TREE_CODE (type);
786 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
787 return size_one_node;
789 if (!COMPLETE_OR_VOID_TYPE_P (type))
791 error ("arithmetic on pointer to an incomplete type");
792 return size_one_node;
795 /* Convert in case a char is more than one unit. */
796 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
797 size_int (TYPE_PRECISION (char_type_node)
801 /* Return either DECL or its known constant value (if it has one). */
804 decl_constant_value (decl)
807 if (/* Don't change a variable array bound or initial value to a constant
808 in a place where a variable is invalid. */
809 current_function_decl != 0
810 && ! TREE_THIS_VOLATILE (decl)
811 && TREE_READONLY (decl)
812 && DECL_INITIAL (decl) != 0
813 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
814 /* This is invalid if initial value is not constant.
815 If it has either a function call, a memory reference,
816 or a variable, then re-evaluating it could give different results. */
817 && TREE_CONSTANT (DECL_INITIAL (decl))
818 /* Check for cases where this is sub-optimal, even though valid. */
819 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
820 return DECL_INITIAL (decl);
824 /* Return either DECL or its known constant value (if it has one), but
825 return DECL if pedantic or DECL has mode BLKmode. This is for
826 bug-compatibility with the old behavior of decl_constant_value
827 (before GCC 3.0); every use of this function is a bug and it should
828 be removed before GCC 3.1. It is not appropriate to use pedantic
829 in a way that affects optimization, and BLKmode is probably not the
830 right test for avoiding misoptimizations either. */
833 decl_constant_value_for_broken_optimization (decl)
836 if (pedantic || DECL_MODE (decl) == BLKmode)
839 return decl_constant_value (decl);
843 /* Perform the default conversion of arrays and functions to pointers.
844 Return the result of converting EXP. For any other expression, just
848 default_function_array_conversion (exp)
852 tree type = TREE_TYPE (exp);
853 enum tree_code code = TREE_CODE (type);
856 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
859 Do not use STRIP_NOPS here! It will remove conversions from pointer
860 to integer and cause infinite recursion. */
862 while (TREE_CODE (exp) == NON_LVALUE_EXPR
863 || (TREE_CODE (exp) == NOP_EXPR
864 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
866 if (TREE_CODE (exp) == NON_LVALUE_EXPR)
868 exp = TREE_OPERAND (exp, 0);
871 /* Preserve the original expression code. */
872 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
873 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
875 if (code == FUNCTION_TYPE)
877 return build_unary_op (ADDR_EXPR, exp, 0);
879 if (code == ARRAY_TYPE)
882 tree restype = TREE_TYPE (type);
888 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
890 constp = TREE_READONLY (exp);
891 volatilep = TREE_THIS_VOLATILE (exp);
894 if (TYPE_QUALS (type) || constp || volatilep)
896 = c_build_qualified_type (restype,
898 | (constp * TYPE_QUAL_CONST)
899 | (volatilep * TYPE_QUAL_VOLATILE));
901 if (TREE_CODE (exp) == INDIRECT_REF)
902 return convert (TYPE_POINTER_TO (restype),
903 TREE_OPERAND (exp, 0));
905 if (TREE_CODE (exp) == COMPOUND_EXPR)
907 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
908 return build (COMPOUND_EXPR, TREE_TYPE (op1),
909 TREE_OPERAND (exp, 0), op1);
912 lvalue_array_p = !not_lvalue && lvalue_p (exp);
913 if (!flag_isoc99 && !lvalue_array_p)
915 /* Before C99, non-lvalue arrays do not decay to pointers.
916 Normally, using such an array would be invalid; but it can
917 be used correctly inside sizeof or as a statement expression.
918 Thus, do not give an error here; an error will result later. */
922 ptrtype = build_pointer_type (restype);
924 if (TREE_CODE (exp) == VAR_DECL)
926 /* ??? This is not really quite correct
927 in that the type of the operand of ADDR_EXPR
928 is not the target type of the type of the ADDR_EXPR itself.
929 Question is, can this lossage be avoided? */
930 adr = build1 (ADDR_EXPR, ptrtype, exp);
931 if (mark_addressable (exp) == 0)
932 return error_mark_node;
933 TREE_CONSTANT (adr) = staticp (exp);
934 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
937 /* This way is better for a COMPONENT_REF since it can
938 simplify the offset for a component. */
939 adr = build_unary_op (ADDR_EXPR, exp, 1);
940 return convert (ptrtype, adr);
945 /* Perform default promotions for C data used in expressions.
946 Arrays and functions are converted to pointers;
947 enumeral types or short or char, to int.
948 In addition, manifest constants symbols are replaced by their values. */
951 default_conversion (exp)
955 tree type = TREE_TYPE (exp);
956 enum tree_code code = TREE_CODE (type);
958 if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
959 return default_function_array_conversion (exp);
961 /* Constants can be used directly unless they're not loadable. */
962 if (TREE_CODE (exp) == CONST_DECL)
963 exp = DECL_INITIAL (exp);
965 /* Replace a nonvolatile const static variable with its value unless
966 it is an array, in which case we must be sure that taking the
967 address of the array produces consistent results. */
968 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
970 exp = decl_constant_value_for_broken_optimization (exp);
971 type = TREE_TYPE (exp);
974 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
977 Do not use STRIP_NOPS here! It will remove conversions from pointer
978 to integer and cause infinite recursion. */
980 while (TREE_CODE (exp) == NON_LVALUE_EXPR
981 || (TREE_CODE (exp) == NOP_EXPR
982 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
983 exp = TREE_OPERAND (exp, 0);
985 /* Preserve the original expression code. */
986 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
987 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
989 /* Normally convert enums to int,
990 but convert wide enums to something wider. */
991 if (code == ENUMERAL_TYPE)
993 type = type_for_size (MAX (TYPE_PRECISION (type),
994 TYPE_PRECISION (integer_type_node)),
996 || (TYPE_PRECISION (type)
997 >= TYPE_PRECISION (integer_type_node)))
998 && TREE_UNSIGNED (type)));
1000 return convert (type, exp);
1003 if (TREE_CODE (exp) == COMPONENT_REF
1004 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1005 /* If it's thinner than an int, promote it like a
1006 c_promoting_integer_type_p, otherwise leave it alone. */
1007 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1008 TYPE_PRECISION (integer_type_node)))
1009 return convert (flag_traditional && TREE_UNSIGNED (type)
1010 ? unsigned_type_node : integer_type_node,
1013 if (c_promoting_integer_type_p (type))
1015 /* Traditionally, unsignedness is preserved in default promotions.
1016 Also preserve unsignedness if not really getting any wider. */
1017 if (TREE_UNSIGNED (type)
1018 && (flag_traditional
1019 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1020 return convert (unsigned_type_node, exp);
1022 return convert (integer_type_node, exp);
1025 if (flag_traditional && !flag_allow_single_precision
1026 && TYPE_MAIN_VARIANT (type) == float_type_node)
1027 return convert (double_type_node, exp);
1029 if (code == VOID_TYPE)
1031 error ("void value not ignored as it ought to be");
1032 return error_mark_node;
1037 /* Look up COMPONENT in a structure or union DECL.
1039 If the component name is not found, returns NULL_TREE. Otherwise,
1040 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1041 stepping down the chain to the component, which is in the last
1042 TREE_VALUE of the list. Normally the list is of length one, but if
1043 the component is embedded within (nested) anonymous structures or
1044 unions, the list steps down the chain to the component. */
1047 lookup_field (decl, component)
1048 tree decl, component;
1050 tree type = TREE_TYPE (decl);
1053 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1054 to the field elements. Use a binary search on this array to quickly
1055 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1056 will always be set for structures which have many elements. */
1058 if (TYPE_LANG_SPECIFIC (type))
1061 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1063 field = TYPE_FIELDS (type);
1065 top = TYPE_LANG_SPECIFIC (type)->len;
1066 while (top - bot > 1)
1068 half = (top - bot + 1) >> 1;
1069 field = field_array[bot+half];
1071 if (DECL_NAME (field) == NULL_TREE)
1073 /* Step through all anon unions in linear fashion. */
1074 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1076 field = field_array[bot++];
1077 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1078 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1080 tree anon = lookup_field (field, component);
1083 return tree_cons (NULL_TREE, field, anon);
1087 /* Entire record is only anon unions. */
1091 /* Restart the binary search, with new lower bound. */
1095 if (DECL_NAME (field) == component)
1097 if (DECL_NAME (field) < component)
1103 if (DECL_NAME (field_array[bot]) == component)
1104 field = field_array[bot];
1105 else if (DECL_NAME (field) != component)
1110 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1112 if (DECL_NAME (field) == NULL_TREE
1113 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1114 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1116 tree anon = lookup_field (field, component);
1119 return tree_cons (NULL_TREE, field, anon);
1122 if (DECL_NAME (field) == component)
1126 if (field == NULL_TREE)
1130 return tree_cons (NULL_TREE, field, NULL_TREE);
1133 /* Make an expression to refer to the COMPONENT field of
1134 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1137 build_component_ref (datum, component)
1138 tree datum, component;
1140 tree type = TREE_TYPE (datum);
1141 enum tree_code code = TREE_CODE (type);
1145 /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
1146 If pedantic ensure that the arguments are not lvalues; otherwise,
1147 if the component is an array, it would wrongly decay to a pointer in
1149 We cannot do this with a COND_EXPR, because in a conditional expression
1150 the default promotions are applied to both sides, and this would yield
1151 the wrong type of the result; for example, if the components have
1153 switch (TREE_CODE (datum))
1157 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1158 return build (COMPOUND_EXPR, TREE_TYPE (value),
1159 TREE_OPERAND (datum, 0), pedantic_non_lvalue (value));
1165 /* See if there is a field or component with name COMPONENT. */
1167 if (code == RECORD_TYPE || code == UNION_TYPE)
1169 if (!COMPLETE_TYPE_P (type))
1171 incomplete_type_error (NULL_TREE, type);
1172 return error_mark_node;
1175 field = lookup_field (datum, component);
1179 error ("%s has no member named `%s'",
1180 code == RECORD_TYPE ? "structure" : "union",
1181 IDENTIFIER_POINTER (component));
1182 return error_mark_node;
1185 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1186 This might be better solved in future the way the C++ front
1187 end does it - by giving the anonymous entities each a
1188 separate name and type, and then have build_component_ref
1189 recursively call itself. We can't do that here. */
1190 for (; field; field = TREE_CHAIN (field))
1192 tree subdatum = TREE_VALUE (field);
1194 if (TREE_TYPE (subdatum) == error_mark_node)
1195 return error_mark_node;
1197 ref = build (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum);
1198 if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1199 TREE_READONLY (ref) = 1;
1200 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1201 TREE_THIS_VOLATILE (ref) = 1;
1203 if (TREE_DEPRECATED (subdatum))
1204 warn_deprecated_use (subdatum);
1211 else if (code != ERROR_MARK)
1212 error ("request for member `%s' in something not a structure or union",
1213 IDENTIFIER_POINTER (component));
1215 return error_mark_node;
1218 /* Given an expression PTR for a pointer, return an expression
1219 for the value pointed to.
1220 ERRORSTRING is the name of the operator to appear in error messages. */
1223 build_indirect_ref (ptr, errorstring)
1225 const char *errorstring;
1227 tree pointer = default_conversion (ptr);
1228 tree type = TREE_TYPE (pointer);
1230 if (TREE_CODE (type) == POINTER_TYPE)
1232 if (TREE_CODE (pointer) == ADDR_EXPR
1234 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1235 == TREE_TYPE (type)))
1236 return TREE_OPERAND (pointer, 0);
1239 tree t = TREE_TYPE (type);
1240 tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1242 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1244 error ("dereferencing pointer to incomplete type");
1245 return error_mark_node;
1247 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1248 warning ("dereferencing `void *' pointer");
1250 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1251 so that we get the proper error message if the result is used
1252 to assign to. Also, &* is supposed to be a no-op.
1253 And ANSI C seems to specify that the type of the result
1254 should be the const type. */
1255 /* A de-reference of a pointer to const is not a const. It is valid
1256 to change it via some other pointer. */
1257 TREE_READONLY (ref) = TYPE_READONLY (t);
1258 TREE_SIDE_EFFECTS (ref)
1259 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1260 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1264 else if (TREE_CODE (pointer) != ERROR_MARK)
1265 error ("invalid type argument of `%s'", errorstring);
1266 return error_mark_node;
1269 /* This handles expressions of the form "a[i]", which denotes
1272 This is logically equivalent in C to *(a+i), but we may do it differently.
1273 If A is a variable or a member, we generate a primitive ARRAY_REF.
1274 This avoids forcing the array out of registers, and can work on
1275 arrays that are not lvalues (for example, members of structures returned
1279 build_array_ref (array, index)
1284 error ("subscript missing in array reference");
1285 return error_mark_node;
1288 if (TREE_TYPE (array) == error_mark_node
1289 || TREE_TYPE (index) == error_mark_node)
1290 return error_mark_node;
1292 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1293 && TREE_CODE (array) != INDIRECT_REF)
1297 /* Subscripting with type char is likely to lose
1298 on a machine where chars are signed.
1299 So warn on any machine, but optionally.
1300 Don't warn for unsigned char since that type is safe.
1301 Don't warn for signed char because anyone who uses that
1302 must have done so deliberately. */
1303 if (warn_char_subscripts
1304 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1305 warning ("array subscript has type `char'");
1307 /* Apply default promotions *after* noticing character types. */
1308 index = default_conversion (index);
1310 /* Require integer *after* promotion, for sake of enums. */
1311 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1313 error ("array subscript is not an integer");
1314 return error_mark_node;
1317 /* An array that is indexed by a non-constant
1318 cannot be stored in a register; we must be able to do
1319 address arithmetic on its address.
1320 Likewise an array of elements of variable size. */
1321 if (TREE_CODE (index) != INTEGER_CST
1322 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1323 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1325 if (mark_addressable (array) == 0)
1326 return error_mark_node;
1328 /* An array that is indexed by a constant value which is not within
1329 the array bounds cannot be stored in a register either; because we
1330 would get a crash in store_bit_field/extract_bit_field when trying
1331 to access a non-existent part of the register. */
1332 if (TREE_CODE (index) == INTEGER_CST
1333 && TYPE_VALUES (TREE_TYPE (array))
1334 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1336 if (mark_addressable (array) == 0)
1337 return error_mark_node;
1343 while (TREE_CODE (foo) == COMPONENT_REF)
1344 foo = TREE_OPERAND (foo, 0);
1345 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1346 pedwarn ("ISO C forbids subscripting `register' array");
1347 else if (! flag_isoc99 && ! lvalue_p (foo))
1348 pedwarn ("ISO C89 forbids subscripting non-lvalue array");
1351 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1352 rval = build (ARRAY_REF, type, array, index);
1353 /* Array ref is const/volatile if the array elements are
1354 or if the array is. */
1355 TREE_READONLY (rval)
1356 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1357 | TREE_READONLY (array));
1358 TREE_SIDE_EFFECTS (rval)
1359 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1360 | TREE_SIDE_EFFECTS (array));
1361 TREE_THIS_VOLATILE (rval)
1362 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1363 /* This was added by rms on 16 Nov 91.
1364 It fixes vol struct foo *a; a->elts[1]
1365 in an inline function.
1366 Hope it doesn't break something else. */
1367 | TREE_THIS_VOLATILE (array));
1368 return require_complete_type (fold (rval));
1372 tree ar = default_conversion (array);
1373 tree ind = default_conversion (index);
1375 /* Do the same warning check as above, but only on the part that's
1376 syntactically the index and only if it is also semantically
1378 if (warn_char_subscripts
1379 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1380 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1381 warning ("subscript has type `char'");
1383 /* Put the integer in IND to simplify error checking. */
1384 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1391 if (ar == error_mark_node)
1394 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1395 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1397 error ("subscripted value is neither array nor pointer");
1398 return error_mark_node;
1400 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1402 error ("array subscript is not an integer");
1403 return error_mark_node;
1406 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1411 /* Build an external reference to identifier ID. FUN indicates
1412 whether this will be used for a function call. */
1414 build_external_ref (id, fun)
1419 tree decl = lookup_name (id);
1420 tree objc_ivar = lookup_objc_ivar (id);
1422 if (decl && TREE_DEPRECATED (decl))
1423 warn_deprecated_use (decl);
1425 if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
1431 if (!decl || decl == error_mark_node)
1432 /* Ordinary implicit function declaration. */
1433 ref = implicitly_declare (id);
1436 /* Implicit declaration of built-in function. Don't
1437 change the built-in declaration, but don't let this
1438 go by silently, either. */
1439 implicit_decl_warning (id);
1441 /* only issue this warning once */
1442 C_DECL_ANTICIPATED (decl) = 0;
1448 /* Reference to undeclared variable, including reference to
1449 builtin outside of function-call context. */
1450 if (current_function_decl == 0)
1451 error ("`%s' undeclared here (not in a function)",
1452 IDENTIFIER_POINTER (id));
1455 if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node
1456 || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl)
1458 error ("`%s' undeclared (first use in this function)",
1459 IDENTIFIER_POINTER (id));
1461 if (! undeclared_variable_notice)
1463 error ("(Each undeclared identifier is reported only once");
1464 error ("for each function it appears in.)");
1465 undeclared_variable_notice = 1;
1468 IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node;
1469 IDENTIFIER_ERROR_LOCUS (id) = current_function_decl;
1471 return error_mark_node;
1476 /* Properly declared variable or function reference. */
1479 else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
1481 warning ("local declaration of `%s' hides instance variable",
1482 IDENTIFIER_POINTER (id));
1489 if (TREE_TYPE (ref) == error_mark_node)
1490 return error_mark_node;
1492 assemble_external (ref);
1493 TREE_USED (ref) = 1;
1495 if (TREE_CODE (ref) == CONST_DECL)
1497 ref = DECL_INITIAL (ref);
1498 TREE_CONSTANT (ref) = 1;
1504 /* Build a function call to function FUNCTION with parameters PARAMS.
1505 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1506 TREE_VALUE of each node is a parameter-expression.
1507 FUNCTION's data type may be a function type or a pointer-to-function. */
1510 build_function_call (function, params)
1511 tree function, params;
1513 tree fntype, fundecl = 0;
1514 tree coerced_params;
1515 tree name = NULL_TREE, assembler_name = NULL_TREE, result;
1517 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1518 STRIP_TYPE_NOPS (function);
1520 /* Convert anything with function type to a pointer-to-function. */
1521 if (TREE_CODE (function) == FUNCTION_DECL)
1523 name = DECL_NAME (function);
1524 assembler_name = DECL_ASSEMBLER_NAME (function);
1526 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1527 (because calling an inline function does not mean the function
1528 needs to be separately compiled). */
1529 fntype = build_type_variant (TREE_TYPE (function),
1530 TREE_READONLY (function),
1531 TREE_THIS_VOLATILE (function));
1533 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1536 function = default_conversion (function);
1538 fntype = TREE_TYPE (function);
1540 if (TREE_CODE (fntype) == ERROR_MARK)
1541 return error_mark_node;
1543 if (!(TREE_CODE (fntype) == POINTER_TYPE
1544 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1546 error ("called object is not a function");
1547 return error_mark_node;
1550 /* fntype now gets the type of function pointed to. */
1551 fntype = TREE_TYPE (fntype);
1553 /* Convert the parameters to the types declared in the
1554 function prototype, or apply default promotions. */
1557 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1559 /* Check for errors in format strings. */
1562 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
1564 /* Recognize certain built-in functions so we can make tree-codes
1565 other than CALL_EXPR. We do this when it enables fold-const.c
1566 to do something useful. */
1568 if (TREE_CODE (function) == ADDR_EXPR
1569 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1570 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1572 result = expand_tree_builtin (TREE_OPERAND (function, 0),
1573 params, coerced_params);
1578 result = build (CALL_EXPR, TREE_TYPE (fntype),
1579 function, coerced_params, NULL_TREE);
1580 TREE_SIDE_EFFECTS (result) = 1;
1581 result = fold (result);
1583 if (VOID_TYPE_P (TREE_TYPE (result)))
1585 return require_complete_type (result);
1588 /* Convert the argument expressions in the list VALUES
1589 to the types in the list TYPELIST. The result is a list of converted
1590 argument expressions.
1592 If TYPELIST is exhausted, or when an element has NULL as its type,
1593 perform the default conversions.
1595 PARMLIST is the chain of parm decls for the function being called.
1596 It may be 0, if that info is not available.
1597 It is used only for generating error messages.
1599 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1601 This is also where warnings about wrong number of args are generated.
1603 Both VALUES and the returned value are chains of TREE_LIST nodes
1604 with the elements of the list in the TREE_VALUE slots of those nodes. */
1607 convert_arguments (typelist, values, name, fundecl)
1608 tree typelist, values, name, fundecl;
1610 tree typetail, valtail;
1614 /* Scan the given expressions and types, producing individual
1615 converted arguments and pushing them on RESULT in reverse order. */
1617 for (valtail = values, typetail = typelist, parmnum = 0;
1619 valtail = TREE_CHAIN (valtail), parmnum++)
1621 tree type = typetail ? TREE_VALUE (typetail) : 0;
1622 tree val = TREE_VALUE (valtail);
1624 if (type == void_type_node)
1627 error ("too many arguments to function `%s'",
1628 IDENTIFIER_POINTER (name));
1630 error ("too many arguments to function");
1634 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1635 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1636 to convert automatically to a pointer. */
1637 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1638 val = TREE_OPERAND (val, 0);
1640 val = default_function_array_conversion (val);
1642 val = require_complete_type (val);
1646 /* Formal parm type is specified by a function prototype. */
1649 if (!COMPLETE_TYPE_P (type))
1651 error ("type of formal parameter %d is incomplete", parmnum + 1);
1656 /* Optionally warn about conversions that
1657 differ from the default conversions. */
1658 if (warn_conversion || warn_traditional)
1660 int formal_prec = TYPE_PRECISION (type);
1662 if (INTEGRAL_TYPE_P (type)
1663 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1664 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1665 if (INTEGRAL_TYPE_P (type)
1666 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1667 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1668 else if (TREE_CODE (type) == COMPLEX_TYPE
1669 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1670 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1671 else if (TREE_CODE (type) == REAL_TYPE
1672 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1673 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1674 else if (TREE_CODE (type) == COMPLEX_TYPE
1675 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1676 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1677 else if (TREE_CODE (type) == REAL_TYPE
1678 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1679 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1680 /* ??? At some point, messages should be written about
1681 conversions between complex types, but that's too messy
1683 else if (TREE_CODE (type) == REAL_TYPE
1684 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1686 /* Warn if any argument is passed as `float',
1687 since without a prototype it would be `double'. */
1688 if (formal_prec == TYPE_PRECISION (float_type_node))
1689 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1691 /* Detect integer changing in width or signedness.
1692 These warnings are only activated with
1693 -Wconversion, not with -Wtraditional. */
1694 else if (warn_conversion && INTEGRAL_TYPE_P (type)
1695 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1697 tree would_have_been = default_conversion (val);
1698 tree type1 = TREE_TYPE (would_have_been);
1700 if (TREE_CODE (type) == ENUMERAL_TYPE
1701 && (TYPE_MAIN_VARIANT (type)
1702 == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
1703 /* No warning if function asks for enum
1704 and the actual arg is that enum type. */
1706 else if (formal_prec != TYPE_PRECISION (type1))
1707 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1708 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1710 /* Don't complain if the formal parameter type
1711 is an enum, because we can't tell now whether
1712 the value was an enum--even the same enum. */
1713 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1715 else if (TREE_CODE (val) == INTEGER_CST
1716 && int_fits_type_p (val, type))
1717 /* Change in signedness doesn't matter
1718 if a constant value is unaffected. */
1720 /* Likewise for a constant in a NOP_EXPR. */
1721 else if (TREE_CODE (val) == NOP_EXPR
1722 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1723 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1725 #if 0 /* We never get such tree structure here. */
1726 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1727 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1728 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1729 /* Change in signedness doesn't matter
1730 if an enum value is unaffected. */
1733 /* If the value is extended from a narrower
1734 unsigned type, it doesn't matter whether we
1735 pass it as signed or unsigned; the value
1736 certainly is the same either way. */
1737 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1738 && TREE_UNSIGNED (TREE_TYPE (val)))
1740 else if (TREE_UNSIGNED (type))
1741 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1743 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1747 parmval = convert_for_assignment (type, val,
1748 (char *) 0, /* arg passing */
1749 fundecl, name, parmnum + 1);
1751 if (PROMOTE_PROTOTYPES
1752 && INTEGRAL_TYPE_P (type)
1753 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1754 parmval = default_conversion (parmval);
1756 result = tree_cons (NULL_TREE, parmval, result);
1758 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1759 && (TYPE_PRECISION (TREE_TYPE (val))
1760 < TYPE_PRECISION (double_type_node)))
1761 /* Convert `float' to `double'. */
1762 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1764 /* Convert `short' and `char' to full-size `int'. */
1765 result = tree_cons (NULL_TREE, default_conversion (val), result);
1768 typetail = TREE_CHAIN (typetail);
1771 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1774 error ("too few arguments to function `%s'",
1775 IDENTIFIER_POINTER (name));
1777 error ("too few arguments to function");
1780 return nreverse (result);
1783 /* This is the entry point used by the parser
1784 for binary operators in the input.
1785 In addition to constructing the expression,
1786 we check for operands that were written with other binary operators
1787 in a way that is likely to confuse the user. */
1790 parser_build_binary_op (code, arg1, arg2)
1791 enum tree_code code;
1794 tree result = build_binary_op (code, arg1, arg2, 1);
1797 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1798 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1799 enum tree_code code1 = ERROR_MARK;
1800 enum tree_code code2 = ERROR_MARK;
1802 if (IS_EXPR_CODE_CLASS (class1))
1803 code1 = C_EXP_ORIGINAL_CODE (arg1);
1804 if (IS_EXPR_CODE_CLASS (class2))
1805 code2 = C_EXP_ORIGINAL_CODE (arg2);
1807 /* Check for cases such as x+y<<z which users are likely
1808 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1809 is cleared to prevent these warnings. */
1810 if (warn_parentheses)
1812 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1814 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1815 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1816 warning ("suggest parentheses around + or - inside shift");
1819 if (code == TRUTH_ORIF_EXPR)
1821 if (code1 == TRUTH_ANDIF_EXPR
1822 || code2 == TRUTH_ANDIF_EXPR)
1823 warning ("suggest parentheses around && within ||");
1826 if (code == BIT_IOR_EXPR)
1828 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1829 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1830 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1831 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1832 warning ("suggest parentheses around arithmetic in operand of |");
1833 /* Check cases like x|y==z */
1834 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1835 warning ("suggest parentheses around comparison in operand of |");
1838 if (code == BIT_XOR_EXPR)
1840 if (code1 == BIT_AND_EXPR
1841 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1842 || code2 == BIT_AND_EXPR
1843 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1844 warning ("suggest parentheses around arithmetic in operand of ^");
1845 /* Check cases like x^y==z */
1846 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1847 warning ("suggest parentheses around comparison in operand of ^");
1850 if (code == BIT_AND_EXPR)
1852 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1853 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1854 warning ("suggest parentheses around + or - in operand of &");
1855 /* Check cases like x&y==z */
1856 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1857 warning ("suggest parentheses around comparison in operand of &");
1861 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1862 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1863 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1864 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1866 unsigned_conversion_warning (result, arg1);
1867 unsigned_conversion_warning (result, arg2);
1868 overflow_warning (result);
1870 class = TREE_CODE_CLASS (TREE_CODE (result));
1872 /* Record the code that was specified in the source,
1873 for the sake of warnings about confusing nesting. */
1874 if (IS_EXPR_CODE_CLASS (class))
1875 C_SET_EXP_ORIGINAL_CODE (result, code);
1878 int flag = TREE_CONSTANT (result);
1879 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1880 so that convert_for_assignment wouldn't strip it.
1881 That way, we got warnings for things like p = (1 - 1).
1882 But it turns out we should not get those warnings. */
1883 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1884 C_SET_EXP_ORIGINAL_CODE (result, code);
1885 TREE_CONSTANT (result) = flag;
1891 /* Build a binary-operation expression without default conversions.
1892 CODE is the kind of expression to build.
1893 This function differs from `build' in several ways:
1894 the data type of the result is computed and recorded in it,
1895 warnings are generated if arg data types are invalid,
1896 special handling for addition and subtraction of pointers is known,
1897 and some optimization is done (operations on narrow ints
1898 are done in the narrower type when that gives the same result).
1899 Constant folding is also done before the result is returned.
1901 Note that the operands will never have enumeral types, or function
1902 or array types, because either they will have the default conversions
1903 performed or they have both just been converted to some other type in which
1904 the arithmetic is to be done. */
1907 build_binary_op (code, orig_op0, orig_op1, convert_p)
1908 enum tree_code code;
1909 tree orig_op0, orig_op1;
1913 enum tree_code code0, code1;
1916 /* Expression code to give to the expression when it is built.
1917 Normally this is CODE, which is what the caller asked for,
1918 but in some special cases we change it. */
1919 enum tree_code resultcode = code;
1921 /* Data type in which the computation is to be performed.
1922 In the simplest cases this is the common type of the arguments. */
1923 tree result_type = NULL;
1925 /* Nonzero means operands have already been type-converted
1926 in whatever way is necessary.
1927 Zero means they need to be converted to RESULT_TYPE. */
1930 /* Nonzero means create the expression with this type, rather than
1932 tree build_type = 0;
1934 /* Nonzero means after finally constructing the expression
1935 convert it to this type. */
1936 tree final_type = 0;
1938 /* Nonzero if this is an operation like MIN or MAX which can
1939 safely be computed in short if both args are promoted shorts.
1940 Also implies COMMON.
1941 -1 indicates a bitwise operation; this makes a difference
1942 in the exact conditions for when it is safe to do the operation
1943 in a narrower mode. */
1946 /* Nonzero if this is a comparison operation;
1947 if both args are promoted shorts, compare the original shorts.
1948 Also implies COMMON. */
1949 int short_compare = 0;
1951 /* Nonzero if this is a right-shift operation, which can be computed on the
1952 original short and then promoted if the operand is a promoted short. */
1953 int short_shift = 0;
1955 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1960 op0 = default_conversion (orig_op0);
1961 op1 = default_conversion (orig_op1);
1969 type0 = TREE_TYPE (op0);
1970 type1 = TREE_TYPE (op1);
1972 /* The expression codes of the data types of the arguments tell us
1973 whether the arguments are integers, floating, pointers, etc. */
1974 code0 = TREE_CODE (type0);
1975 code1 = TREE_CODE (type1);
1977 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1978 STRIP_TYPE_NOPS (op0);
1979 STRIP_TYPE_NOPS (op1);
1981 /* If an error was already reported for one of the arguments,
1982 avoid reporting another error. */
1984 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
1985 return error_mark_node;
1990 /* Handle the pointer + int case. */
1991 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1992 return pointer_int_sum (PLUS_EXPR, op0, op1);
1993 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
1994 return pointer_int_sum (PLUS_EXPR, op1, op0);
2000 /* Subtraction of two similar pointers.
2001 We must subtract them as integers, then divide by object size. */
2002 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2003 && comp_target_types (type0, type1))
2004 return pointer_diff (op0, op1);
2005 /* Handle pointer minus int. Just like pointer plus int. */
2006 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2007 return pointer_int_sum (MINUS_EXPR, op0, op1);
2016 case TRUNC_DIV_EXPR:
2018 case FLOOR_DIV_EXPR:
2019 case ROUND_DIV_EXPR:
2020 case EXACT_DIV_EXPR:
2021 /* Floating point division by zero is a legitimate way to obtain
2022 infinities and NaNs. */
2023 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2024 warning ("division by zero");
2026 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2027 || code0 == COMPLEX_TYPE)
2028 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2029 || code1 == COMPLEX_TYPE))
2031 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2032 resultcode = RDIV_EXPR;
2034 /* Although it would be tempting to shorten always here, that
2035 loses on some targets, since the modulo instruction is
2036 undefined if the quotient can't be represented in the
2037 computation mode. We shorten only if unsigned or if
2038 dividing by something we know != -1. */
2039 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2040 || (TREE_CODE (op1) == INTEGER_CST
2041 && ! integer_all_onesp (op1)));
2047 case BIT_ANDTC_EXPR:
2050 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2052 /* If one operand is a constant, and the other is a short type
2053 that has been converted to an int,
2054 really do the work in the short type and then convert the
2055 result to int. If we are lucky, the constant will be 0 or 1
2056 in the short type, making the entire operation go away. */
2057 if (TREE_CODE (op0) == INTEGER_CST
2058 && TREE_CODE (op1) == NOP_EXPR
2059 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2060 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2062 final_type = result_type;
2063 op1 = TREE_OPERAND (op1, 0);
2064 result_type = TREE_TYPE (op1);
2066 if (TREE_CODE (op1) == INTEGER_CST
2067 && TREE_CODE (op0) == NOP_EXPR
2068 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2069 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2071 final_type = result_type;
2072 op0 = TREE_OPERAND (op0, 0);
2073 result_type = TREE_TYPE (op0);
2077 case TRUNC_MOD_EXPR:
2078 case FLOOR_MOD_EXPR:
2079 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
2080 warning ("division by zero");
2082 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2084 /* Although it would be tempting to shorten always here, that loses
2085 on some targets, since the modulo instruction is undefined if the
2086 quotient can't be represented in the computation mode. We shorten
2087 only if unsigned or if dividing by something we know != -1. */
2088 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2089 || (TREE_CODE (op1) == INTEGER_CST
2090 && ! integer_all_onesp (op1)));
2095 case TRUTH_ANDIF_EXPR:
2096 case TRUTH_ORIF_EXPR:
2097 case TRUTH_AND_EXPR:
2099 case TRUTH_XOR_EXPR:
2100 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2101 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2102 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2103 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2105 /* Result of these operations is always an int,
2106 but that does not mean the operands should be
2107 converted to ints! */
2108 result_type = integer_type_node;
2109 op0 = truthvalue_conversion (op0);
2110 op1 = truthvalue_conversion (op1);
2115 /* Shift operations: result has same type as first operand;
2116 always convert second operand to int.
2117 Also set SHORT_SHIFT if shifting rightward. */
2120 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2122 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2124 if (tree_int_cst_sgn (op1) < 0)
2125 warning ("right shift count is negative");
2128 if (! integer_zerop (op1))
2131 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2132 warning ("right shift count >= width of type");
2136 /* Use the type of the value to be shifted.
2137 This is what most traditional C compilers do. */
2138 result_type = type0;
2139 /* Unless traditional, convert the shift-count to an integer,
2140 regardless of size of value being shifted. */
2141 if (! flag_traditional)
2143 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2144 op1 = convert (integer_type_node, op1);
2145 /* Avoid converting op1 to result_type later. */
2152 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2154 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2156 if (tree_int_cst_sgn (op1) < 0)
2157 warning ("left shift count is negative");
2159 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2160 warning ("left shift count >= width of type");
2163 /* Use the type of the value to be shifted.
2164 This is what most traditional C compilers do. */
2165 result_type = type0;
2166 /* Unless traditional, convert the shift-count to an integer,
2167 regardless of size of value being shifted. */
2168 if (! flag_traditional)
2170 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2171 op1 = convert (integer_type_node, op1);
2172 /* Avoid converting op1 to result_type later. */
2180 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2182 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2184 if (tree_int_cst_sgn (op1) < 0)
2185 warning ("shift count is negative");
2186 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2187 warning ("shift count >= width of type");
2190 /* Use the type of the value to be shifted.
2191 This is what most traditional C compilers do. */
2192 result_type = type0;
2193 /* Unless traditional, convert the shift-count to an integer,
2194 regardless of size of value being shifted. */
2195 if (! flag_traditional)
2197 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2198 op1 = convert (integer_type_node, op1);
2199 /* Avoid converting op1 to result_type later. */
2207 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2208 warning ("comparing floating point with == or != is unsafe");
2209 /* Result of comparison is always int,
2210 but don't convert the args to int! */
2211 build_type = integer_type_node;
2212 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2213 || code0 == COMPLEX_TYPE)
2214 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2215 || code1 == COMPLEX_TYPE))
2217 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2219 tree tt0 = TREE_TYPE (type0);
2220 tree tt1 = TREE_TYPE (type1);
2221 /* Anything compares with void *. void * compares with anything.
2222 Otherwise, the targets must be compatible
2223 and both must be object or both incomplete. */
2224 if (comp_target_types (type0, type1))
2225 result_type = common_type (type0, type1);
2226 else if (VOID_TYPE_P (tt0))
2228 /* op0 != orig_op0 detects the case of something
2229 whose value is 0 but which isn't a valid null ptr const. */
2230 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2231 && TREE_CODE (tt1) == FUNCTION_TYPE)
2232 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2234 else if (VOID_TYPE_P (tt1))
2236 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2237 && TREE_CODE (tt0) == FUNCTION_TYPE)
2238 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2241 pedwarn ("comparison of distinct pointer types lacks a cast");
2243 if (result_type == NULL_TREE)
2244 result_type = ptr_type_node;
2246 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2247 && integer_zerop (op1))
2248 result_type = type0;
2249 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2250 && integer_zerop (op0))
2251 result_type = type1;
2252 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2254 result_type = type0;
2255 if (! flag_traditional)
2256 pedwarn ("comparison between pointer and integer");
2258 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2260 result_type = type1;
2261 if (! flag_traditional)
2262 pedwarn ("comparison between pointer and integer");
2268 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2269 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2271 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2273 if (comp_target_types (type0, type1))
2275 result_type = common_type (type0, type1);
2277 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2278 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2282 result_type = ptr_type_node;
2283 pedwarn ("comparison of distinct pointer types lacks a cast");
2292 build_type = integer_type_node;
2293 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2294 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2296 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2298 if (comp_target_types (type0, type1))
2300 result_type = common_type (type0, type1);
2301 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2302 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2303 pedwarn ("comparison of complete and incomplete pointers");
2305 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2306 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2310 result_type = ptr_type_node;
2311 pedwarn ("comparison of distinct pointer types lacks a cast");
2314 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2315 && integer_zerop (op1))
2317 result_type = type0;
2318 if (pedantic || extra_warnings)
2319 pedwarn ("ordered comparison of pointer with integer zero");
2321 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2322 && integer_zerop (op0))
2324 result_type = type1;
2326 pedwarn ("ordered comparison of pointer with integer zero");
2328 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2330 result_type = type0;
2331 if (! flag_traditional)
2332 pedwarn ("comparison between pointer and integer");
2334 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2336 result_type = type1;
2337 if (! flag_traditional)
2338 pedwarn ("comparison between pointer and integer");
2342 case UNORDERED_EXPR:
2349 build_type = integer_type_node;
2350 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2352 error ("unordered comparison on non-floating point argument");
2353 return error_mark_node;
2362 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2364 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2366 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2368 if (shorten || common || short_compare)
2369 result_type = common_type (type0, type1);
2371 /* For certain operations (which identify themselves by shorten != 0)
2372 if both args were extended from the same smaller type,
2373 do the arithmetic in that type and then extend.
2375 shorten !=0 and !=1 indicates a bitwise operation.
2376 For them, this optimization is safe only if
2377 both args are zero-extended or both are sign-extended.
2378 Otherwise, we might change the result.
2379 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2380 but calculated in (unsigned short) it would be (unsigned short)-1. */
2382 if (shorten && none_complex)
2384 int unsigned0, unsigned1;
2385 tree arg0 = get_narrower (op0, &unsigned0);
2386 tree arg1 = get_narrower (op1, &unsigned1);
2387 /* UNS is 1 if the operation to be done is an unsigned one. */
2388 int uns = TREE_UNSIGNED (result_type);
2391 final_type = result_type;
2393 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2394 but it *requires* conversion to FINAL_TYPE. */
2396 if ((TYPE_PRECISION (TREE_TYPE (op0))
2397 == TYPE_PRECISION (TREE_TYPE (arg0)))
2398 && TREE_TYPE (op0) != final_type)
2399 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2400 if ((TYPE_PRECISION (TREE_TYPE (op1))
2401 == TYPE_PRECISION (TREE_TYPE (arg1)))
2402 && TREE_TYPE (op1) != final_type)
2403 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2405 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2407 /* For bitwise operations, signedness of nominal type
2408 does not matter. Consider only how operands were extended. */
2412 /* Note that in all three cases below we refrain from optimizing
2413 an unsigned operation on sign-extended args.
2414 That would not be valid. */
2416 /* Both args variable: if both extended in same way
2417 from same width, do it in that width.
2418 Do it unsigned if args were zero-extended. */
2419 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2420 < TYPE_PRECISION (result_type))
2421 && (TYPE_PRECISION (TREE_TYPE (arg1))
2422 == TYPE_PRECISION (TREE_TYPE (arg0)))
2423 && unsigned0 == unsigned1
2424 && (unsigned0 || !uns))
2426 = signed_or_unsigned_type (unsigned0,
2427 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2428 else if (TREE_CODE (arg0) == INTEGER_CST
2429 && (unsigned1 || !uns)
2430 && (TYPE_PRECISION (TREE_TYPE (arg1))
2431 < TYPE_PRECISION (result_type))
2432 && (type = signed_or_unsigned_type (unsigned1,
2434 int_fits_type_p (arg0, type)))
2436 else if (TREE_CODE (arg1) == INTEGER_CST
2437 && (unsigned0 || !uns)
2438 && (TYPE_PRECISION (TREE_TYPE (arg0))
2439 < TYPE_PRECISION (result_type))
2440 && (type = signed_or_unsigned_type (unsigned0,
2442 int_fits_type_p (arg1, type)))
2446 /* Shifts can be shortened if shifting right. */
2451 tree arg0 = get_narrower (op0, &unsigned_arg);
2453 final_type = result_type;
2455 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2456 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2458 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2459 /* We can shorten only if the shift count is less than the
2460 number of bits in the smaller type size. */
2461 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2462 /* We cannot drop an unsigned shift after sign-extension. */
2463 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2465 /* Do an unsigned shift if the operand was zero-extended. */
2467 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
2468 /* Convert value-to-be-shifted to that type. */
2469 if (TREE_TYPE (op0) != result_type)
2470 op0 = convert (result_type, op0);
2475 /* Comparison operations are shortened too but differently.
2476 They identify themselves by setting short_compare = 1. */
2480 /* Don't write &op0, etc., because that would prevent op0
2481 from being kept in a register.
2482 Instead, make copies of the our local variables and
2483 pass the copies by reference, then copy them back afterward. */
2484 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2485 enum tree_code xresultcode = resultcode;
2487 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2492 op0 = xop0, op1 = xop1;
2494 resultcode = xresultcode;
2496 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2497 && skip_evaluation == 0)
2499 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2500 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2501 int unsignedp0, unsignedp1;
2502 tree primop0 = get_narrower (op0, &unsignedp0);
2503 tree primop1 = get_narrower (op1, &unsignedp1);
2507 STRIP_TYPE_NOPS (xop0);
2508 STRIP_TYPE_NOPS (xop1);
2510 /* Give warnings for comparisons between signed and unsigned
2511 quantities that may fail.
2513 Do the checking based on the original operand trees, so that
2514 casts will be considered, but default promotions won't be.
2516 Do not warn if the comparison is being done in a signed type,
2517 since the signed type will only be chosen if it can represent
2518 all the values of the unsigned type. */
2519 if (! TREE_UNSIGNED (result_type))
2521 /* Do not warn if both operands are the same signedness. */
2522 else if (op0_signed == op1_signed)
2529 sop = xop0, uop = xop1;
2531 sop = xop1, uop = xop0;
2533 /* Do not warn if the signed quantity is an
2534 unsuffixed integer literal (or some static
2535 constant expression involving such literals or a
2536 conditional expression involving such literals)
2537 and it is non-negative. */
2538 if (tree_expr_nonnegative_p (sop))
2540 /* Do not warn if the comparison is an equality operation,
2541 the unsigned quantity is an integral constant, and it
2542 would fit in the result if the result were signed. */
2543 else if (TREE_CODE (uop) == INTEGER_CST
2544 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2545 && int_fits_type_p (uop, signed_type (result_type)))
2547 /* Do not warn if the unsigned quantity is an enumeration
2548 constant and its maximum value would fit in the result
2549 if the result were signed. */
2550 else if (TREE_CODE (uop) == INTEGER_CST
2551 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2552 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2553 signed_type (result_type)))
2556 warning ("comparison between signed and unsigned");
2559 /* Warn if two unsigned values are being compared in a size
2560 larger than their original size, and one (and only one) is the
2561 result of a `~' operator. This comparison will always fail.
2563 Also warn if one operand is a constant, and the constant
2564 does not have all bits set that are set in the ~ operand
2565 when it is extended. */
2567 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2568 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2570 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2571 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2574 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2577 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2580 HOST_WIDE_INT constant, mask;
2581 int unsignedp, bits;
2583 if (host_integerp (primop0, 0))
2586 unsignedp = unsignedp1;
2587 constant = tree_low_cst (primop0, 0);
2592 unsignedp = unsignedp0;
2593 constant = tree_low_cst (primop1, 0);
2596 bits = TYPE_PRECISION (TREE_TYPE (primop));
2597 if (bits < TYPE_PRECISION (result_type)
2598 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2600 mask = (~ (HOST_WIDE_INT) 0) << bits;
2601 if ((mask & constant) != mask)
2602 warning ("comparison of promoted ~unsigned with constant");
2605 else if (unsignedp0 && unsignedp1
2606 && (TYPE_PRECISION (TREE_TYPE (primop0))
2607 < TYPE_PRECISION (result_type))
2608 && (TYPE_PRECISION (TREE_TYPE (primop1))
2609 < TYPE_PRECISION (result_type)))
2610 warning ("comparison of promoted ~unsigned with unsigned");
2616 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2617 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2618 Then the expression will be built.
2619 It will be given type FINAL_TYPE if that is nonzero;
2620 otherwise, it will be given type RESULT_TYPE. */
2624 binary_op_error (code);
2625 return error_mark_node;
2630 if (TREE_TYPE (op0) != result_type)
2631 op0 = convert (result_type, op0);
2632 if (TREE_TYPE (op1) != result_type)
2633 op1 = convert (result_type, op1);
2636 if (build_type == NULL_TREE)
2637 build_type = result_type;
2640 tree result = build (resultcode, build_type, op0, op1);
2643 folded = fold (result);
2644 if (folded == result)
2645 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2646 if (final_type != 0)
2647 return convert (final_type, folded);
2652 /* Return a tree for the sum or difference (RESULTCODE says which)
2653 of pointer PTROP and integer INTOP. */
2656 pointer_int_sum (resultcode, ptrop, intop)
2657 enum tree_code resultcode;
2665 /* The result is a pointer of the same type that is being added. */
2667 tree result_type = TREE_TYPE (ptrop);
2669 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2671 if (pedantic || warn_pointer_arith)
2672 pedwarn ("pointer of type `void *' used in arithmetic");
2673 size_exp = integer_one_node;
2675 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2677 if (pedantic || warn_pointer_arith)
2678 pedwarn ("pointer to a function used in arithmetic");
2679 size_exp = integer_one_node;
2682 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2684 /* If what we are about to multiply by the size of the elements
2685 contains a constant term, apply distributive law
2686 and multiply that constant term separately.
2687 This helps produce common subexpressions. */
2689 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2690 && ! TREE_CONSTANT (intop)
2691 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2692 && TREE_CONSTANT (size_exp)
2693 /* If the constant comes from pointer subtraction,
2694 skip this optimization--it would cause an error. */
2695 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2696 /* If the constant is unsigned, and smaller than the pointer size,
2697 then we must skip this optimization. This is because it could cause
2698 an overflow error if the constant is negative but INTOP is not. */
2699 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2700 || (TYPE_PRECISION (TREE_TYPE (intop))
2701 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2703 enum tree_code subcode = resultcode;
2704 tree int_type = TREE_TYPE (intop);
2705 if (TREE_CODE (intop) == MINUS_EXPR)
2706 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2707 /* Convert both subexpression types to the type of intop,
2708 because weird cases involving pointer arithmetic
2709 can result in a sum or difference with different type args. */
2710 ptrop = build_binary_op (subcode, ptrop,
2711 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2712 intop = convert (int_type, TREE_OPERAND (intop, 0));
2715 /* Convert the integer argument to a type the same size as sizetype
2716 so the multiply won't overflow spuriously. */
2718 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2719 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2720 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2721 TREE_UNSIGNED (sizetype)), intop);
2723 /* Replace the integer argument with a suitable product by the object size.
2724 Do this multiplication as signed, then convert to the appropriate
2725 pointer type (actually unsigned integral). */
2727 intop = convert (result_type,
2728 build_binary_op (MULT_EXPR, intop,
2729 convert (TREE_TYPE (intop), size_exp), 1));
2731 /* Create the sum or difference. */
2733 result = build (resultcode, result_type, ptrop, intop);
2735 folded = fold (result);
2736 if (folded == result)
2737 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2741 /* Return a tree for the difference of pointers OP0 and OP1.
2742 The resulting tree has type int. */
2745 pointer_diff (op0, op1)
2748 tree result, folded;
2749 tree restype = ptrdiff_type_node;
2751 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2752 tree con0, con1, lit0, lit1;
2753 tree orig_op1 = op1;
2755 if (pedantic || warn_pointer_arith)
2757 if (TREE_CODE (target_type) == VOID_TYPE)
2758 pedwarn ("pointer of type `void *' used in subtraction");
2759 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2760 pedwarn ("pointer to a function used in subtraction");
2763 /* If the conversion to ptrdiff_type does anything like widening or
2764 converting a partial to an integral mode, we get a convert_expression
2765 that is in the way to do any simplifications.
2766 (fold-const.c doesn't know that the extra bits won't be needed.
2767 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2768 different mode in place.)
2769 So first try to find a common term here 'by hand'; we want to cover
2770 at least the cases that occur in legal static initializers. */
2771 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2772 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2774 if (TREE_CODE (con0) == PLUS_EXPR)
2776 lit0 = TREE_OPERAND (con0, 1);
2777 con0 = TREE_OPERAND (con0, 0);
2780 lit0 = integer_zero_node;
2782 if (TREE_CODE (con1) == PLUS_EXPR)
2784 lit1 = TREE_OPERAND (con1, 1);
2785 con1 = TREE_OPERAND (con1, 0);
2788 lit1 = integer_zero_node;
2790 if (operand_equal_p (con0, con1, 0))
2797 /* First do the subtraction as integers;
2798 then drop through to build the divide operator.
2799 Do not do default conversions on the minus operator
2800 in case restype is a short type. */
2802 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2803 convert (restype, op1), 0);
2804 /* This generates an error if op1 is pointer to incomplete type. */
2805 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2806 error ("arithmetic on pointer to an incomplete type");
2808 /* This generates an error if op0 is pointer to incomplete type. */
2809 op1 = c_size_in_bytes (target_type);
2811 /* Divide by the size, in easiest possible way. */
2813 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2815 folded = fold (result);
2816 if (folded == result)
2817 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2821 /* Construct and perhaps optimize a tree representation
2822 for a unary operation. CODE, a tree_code, specifies the operation
2823 and XARG is the operand.
2824 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2825 the default promotions (such as from short to int).
2826 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2827 allows non-lvalues; this is only used to handle conversion of non-lvalue
2828 arrays to pointers in C99. */
2831 build_unary_op (code, xarg, flag)
2832 enum tree_code code;
2836 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2839 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2841 int noconvert = flag;
2843 if (typecode == ERROR_MARK)
2844 return error_mark_node;
2845 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2846 typecode = INTEGER_TYPE;
2851 /* This is used for unary plus, because a CONVERT_EXPR
2852 is enough to prevent anybody from looking inside for
2853 associativity, but won't generate any code. */
2854 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2855 || typecode == COMPLEX_TYPE))
2857 error ("wrong type argument to unary plus");
2858 return error_mark_node;
2860 else if (!noconvert)
2861 arg = default_conversion (arg);
2865 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2866 || typecode == COMPLEX_TYPE))
2868 error ("wrong type argument to unary minus");
2869 return error_mark_node;
2871 else if (!noconvert)
2872 arg = default_conversion (arg);
2876 if (typecode == COMPLEX_TYPE)
2880 pedwarn ("ISO C does not support `~' for complex conjugation");
2882 arg = default_conversion (arg);
2884 else if (typecode != INTEGER_TYPE)
2886 error ("wrong type argument to bit-complement");
2887 return error_mark_node;
2889 else if (!noconvert)
2890 arg = default_conversion (arg);
2894 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2895 || typecode == COMPLEX_TYPE))
2897 error ("wrong type argument to abs");
2898 return error_mark_node;
2900 else if (!noconvert)
2901 arg = default_conversion (arg);
2905 /* Conjugating a real value is a no-op, but allow it anyway. */
2906 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2907 || typecode == COMPLEX_TYPE))
2909 error ("wrong type argument to conjugation");
2910 return error_mark_node;
2912 else if (!noconvert)
2913 arg = default_conversion (arg);
2916 case TRUTH_NOT_EXPR:
2917 if (typecode != INTEGER_TYPE
2918 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2919 && typecode != COMPLEX_TYPE
2920 /* These will convert to a pointer. */
2921 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2923 error ("wrong type argument to unary exclamation mark");
2924 return error_mark_node;
2926 arg = truthvalue_conversion (arg);
2927 return invert_truthvalue (arg);
2933 if (TREE_CODE (arg) == COMPLEX_CST)
2934 return TREE_REALPART (arg);
2935 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2936 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2941 if (TREE_CODE (arg) == COMPLEX_CST)
2942 return TREE_IMAGPART (arg);
2943 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2944 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2946 return convert (TREE_TYPE (arg), integer_zero_node);
2948 case PREINCREMENT_EXPR:
2949 case POSTINCREMENT_EXPR:
2950 case PREDECREMENT_EXPR:
2951 case POSTDECREMENT_EXPR:
2952 /* Handle complex lvalues (when permitted)
2953 by reduction to simpler cases. */
2955 val = unary_complex_lvalue (code, arg, 0);
2959 /* Increment or decrement the real part of the value,
2960 and don't change the imaginary part. */
2961 if (typecode == COMPLEX_TYPE)
2966 pedwarn ("ISO C does not support `++' and `--' on complex types");
2968 arg = stabilize_reference (arg);
2969 real = build_unary_op (REALPART_EXPR, arg, 1);
2970 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2971 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2972 build_unary_op (code, real, 1), imag);
2975 /* Report invalid types. */
2977 if (typecode != POINTER_TYPE
2978 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2980 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2981 error ("wrong type argument to increment");
2983 error ("wrong type argument to decrement");
2985 return error_mark_node;
2990 tree result_type = TREE_TYPE (arg);
2992 arg = get_unwidened (arg, 0);
2993 argtype = TREE_TYPE (arg);
2995 /* Compute the increment. */
2997 if (typecode == POINTER_TYPE)
2999 /* If pointer target is an undefined struct,
3000 we just cannot know how to do the arithmetic. */
3001 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
3003 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3004 error ("increment of pointer to unknown structure");
3006 error ("decrement of pointer to unknown structure");
3008 else if ((pedantic || warn_pointer_arith)
3009 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
3010 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
3012 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3013 pedwarn ("wrong type argument to increment");
3015 pedwarn ("wrong type argument to decrement");
3018 inc = c_size_in_bytes (TREE_TYPE (result_type));
3021 inc = integer_one_node;
3023 inc = convert (argtype, inc);
3025 /* Handle incrementing a cast-expression. */
3028 switch (TREE_CODE (arg))
3033 case FIX_TRUNC_EXPR:
3034 case FIX_FLOOR_EXPR:
3035 case FIX_ROUND_EXPR:
3037 pedantic_lvalue_warning (CONVERT_EXPR);
3038 /* If the real type has the same machine representation
3039 as the type it is cast to, we can make better output
3040 by adding directly to the inside of the cast. */
3041 if ((TREE_CODE (TREE_TYPE (arg))
3042 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
3043 && (TYPE_MODE (TREE_TYPE (arg))
3044 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
3045 arg = TREE_OPERAND (arg, 0);
3048 tree incremented, modify, value;
3049 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3050 value = boolean_increment (code, arg);
3053 arg = stabilize_reference (arg);
3054 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3057 value = save_expr (arg);
3058 incremented = build (((code == PREINCREMENT_EXPR
3059 || code == POSTINCREMENT_EXPR)
3060 ? PLUS_EXPR : MINUS_EXPR),
3061 argtype, value, inc);
3062 TREE_SIDE_EFFECTS (incremented) = 1;
3063 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3064 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3066 TREE_USED (value) = 1;
3076 /* Complain about anything else that is not a true lvalue. */
3077 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3078 || code == POSTINCREMENT_EXPR)
3079 ? "invalid lvalue in increment"
3080 : "invalid lvalue in decrement")))
3081 return error_mark_node;
3083 /* Report a read-only lvalue. */
3084 if (TREE_READONLY (arg))
3085 readonly_warning (arg,
3086 ((code == PREINCREMENT_EXPR
3087 || code == POSTINCREMENT_EXPR)
3088 ? _("increment") : _("decrement")));
3090 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3091 val = boolean_increment (code, arg);
3093 val = build (code, TREE_TYPE (arg), arg, inc);
3094 TREE_SIDE_EFFECTS (val) = 1;
3095 val = convert (result_type, val);
3096 if (TREE_CODE (val) != code)
3097 TREE_NO_UNUSED_WARNING (val) = 1;
3102 /* Note that this operation never does default_conversion. */
3104 /* Let &* cancel out to simplify resulting code. */
3105 if (TREE_CODE (arg) == INDIRECT_REF)
3107 /* Don't let this be an lvalue. */
3108 if (lvalue_p (TREE_OPERAND (arg, 0)))
3109 return non_lvalue (TREE_OPERAND (arg, 0));
3110 return TREE_OPERAND (arg, 0);
3113 /* For &x[y], return x+y */
3114 if (TREE_CODE (arg) == ARRAY_REF)
3116 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3117 return error_mark_node;
3118 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3119 TREE_OPERAND (arg, 1), 1);
3122 /* Handle complex lvalues (when permitted)
3123 by reduction to simpler cases. */
3124 val = unary_complex_lvalue (code, arg, flag);
3128 #if 0 /* Turned off because inconsistent;
3129 float f; *&(int)f = 3.4 stores in int format
3130 whereas (int)f = 3.4 stores in float format. */
3131 /* Address of a cast is just a cast of the address
3132 of the operand of the cast. */
3133 switch (TREE_CODE (arg))
3138 case FIX_TRUNC_EXPR:
3139 case FIX_FLOOR_EXPR:
3140 case FIX_ROUND_EXPR:
3143 pedwarn ("ISO C forbids the address of a cast expression");
3144 return convert (build_pointer_type (TREE_TYPE (arg)),
3145 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3150 /* Anything not already handled and not a true memory reference
3151 or a non-lvalue array is an error. */
3152 else if (typecode != FUNCTION_TYPE && !flag
3153 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3154 return error_mark_node;
3156 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3157 argtype = TREE_TYPE (arg);
3159 /* If the lvalue is const or volatile, merge that into the type
3160 to which the address will point. Note that you can't get a
3161 restricted pointer by taking the address of something, so we
3162 only have to deal with `const' and `volatile' here. */
3163 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3164 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3165 argtype = c_build_type_variant (argtype,
3166 TREE_READONLY (arg),
3167 TREE_THIS_VOLATILE (arg));
3169 argtype = build_pointer_type (argtype);
3171 if (mark_addressable (arg) == 0)
3172 return error_mark_node;
3177 if (TREE_CODE (arg) == COMPONENT_REF)
3179 tree field = TREE_OPERAND (arg, 1);
3181 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
3183 if (DECL_C_BIT_FIELD (field))
3185 error ("attempt to take address of bit-field structure member `%s'",
3186 IDENTIFIER_POINTER (DECL_NAME (field)));
3187 return error_mark_node;
3190 addr = fold (build (PLUS_EXPR, argtype,
3191 convert (argtype, addr),
3192 convert (argtype, byte_position (field))));
3195 addr = build1 (code, argtype, arg);
3197 /* Address of a static or external variable or
3198 file-scope function counts as a constant. */
3200 && ! (TREE_CODE (arg) == FUNCTION_DECL
3201 && DECL_CONTEXT (arg) != 0))
3202 TREE_CONSTANT (addr) = 1;
3211 argtype = TREE_TYPE (arg);
3212 return fold (build1 (code, argtype, arg));
3216 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3217 convert ARG with the same conversions in the same order
3218 and return the result. */
3221 convert_sequence (conversions, arg)
3225 switch (TREE_CODE (conversions))
3230 case FIX_TRUNC_EXPR:
3231 case FIX_FLOOR_EXPR:
3232 case FIX_ROUND_EXPR:
3234 return convert (TREE_TYPE (conversions),
3235 convert_sequence (TREE_OPERAND (conversions, 0),
3244 /* Return nonzero if REF is an lvalue valid for this language.
3245 Lvalues can be assigned, unless their type has TYPE_READONLY.
3246 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3252 enum tree_code code = TREE_CODE (ref);
3259 return lvalue_p (TREE_OPERAND (ref, 0));
3261 case COMPOUND_LITERAL_EXPR:
3271 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3272 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3276 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3283 /* Return nonzero if REF is an lvalue valid for this language;
3284 otherwise, print an error message and return zero. */
3287 lvalue_or_else (ref, msgid)
3291 int win = lvalue_p (ref);
3294 error ("%s", msgid);
3299 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3300 for certain kinds of expressions which are not really lvalues
3301 but which we can accept as lvalues. If FLAG is nonzero, then
3302 non-lvalues are OK since we may be converting a non-lvalue array to
3305 If ARG is not a kind of expression we can handle, return zero. */
3308 unary_complex_lvalue (code, arg, flag)
3309 enum tree_code code;
3313 /* Handle (a, b) used as an "lvalue". */
3314 if (TREE_CODE (arg) == COMPOUND_EXPR)
3316 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3318 /* If this returns a function type, it isn't really being used as
3319 an lvalue, so don't issue a warning about it. */
3320 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3321 pedantic_lvalue_warning (COMPOUND_EXPR);
3323 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3324 TREE_OPERAND (arg, 0), real_result);
3327 /* Handle (a ? b : c) used as an "lvalue". */
3328 if (TREE_CODE (arg) == COND_EXPR)
3331 pedantic_lvalue_warning (COND_EXPR);
3332 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
3333 pedantic_lvalue_warning (COMPOUND_EXPR);
3335 return (build_conditional_expr
3336 (TREE_OPERAND (arg, 0),
3337 build_unary_op (code, TREE_OPERAND (arg, 1), flag),
3338 build_unary_op (code, TREE_OPERAND (arg, 2), flag)));
3344 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3345 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3348 pedantic_lvalue_warning (code)
3349 enum tree_code code;
3355 pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3358 pedwarn ("ISO C forbids use of compound expressions as lvalues");
3361 pedwarn ("ISO C forbids use of cast expressions as lvalues");
3366 /* Warn about storing in something that is `const'. */
3369 readonly_warning (arg, msgid)
3373 if (TREE_CODE (arg) == COMPONENT_REF)
3375 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3376 readonly_warning (TREE_OPERAND (arg, 0), msgid);
3378 pedwarn ("%s of read-only member `%s'", _(msgid),
3379 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3381 else if (TREE_CODE (arg) == VAR_DECL)
3382 pedwarn ("%s of read-only variable `%s'", _(msgid),
3383 IDENTIFIER_POINTER (DECL_NAME (arg)));
3385 pedwarn ("%s of read-only location", _(msgid));
3388 /* Mark EXP saying that we need to be able to take the
3389 address of it; it should not be allocated in a register.
3390 Value is 1 if successful. */
3393 mark_addressable (exp)
3398 switch (TREE_CODE (x))
3401 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3403 error ("cannot take address of bit-field `%s'",
3404 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3408 /* ... fall through ... */
3414 x = TREE_OPERAND (x, 0);
3417 case COMPOUND_LITERAL_EXPR:
3419 TREE_ADDRESSABLE (x) = 1;
3426 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3427 && DECL_NONLOCAL (x))
3429 if (TREE_PUBLIC (x))
3431 error ("global register variable `%s' used in nested function",
3432 IDENTIFIER_POINTER (DECL_NAME (x)));
3435 pedwarn ("register variable `%s' used in nested function",
3436 IDENTIFIER_POINTER (DECL_NAME (x)));
3438 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3440 if (TREE_PUBLIC (x))
3442 error ("address of global register variable `%s' requested",
3443 IDENTIFIER_POINTER (DECL_NAME (x)));
3447 /* If we are making this addressable due to its having
3448 volatile components, give a different error message. Also
3449 handle the case of an unnamed parameter by not trying
3450 to give the name. */
3452 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3454 error ("cannot put object with volatile field into register");
3458 pedwarn ("address of register variable `%s' requested",
3459 IDENTIFIER_POINTER (DECL_NAME (x)));
3461 put_var_into_stack (x);
3465 TREE_ADDRESSABLE (x) = 1;
3466 #if 0 /* poplevel deals with this now. */
3467 if (DECL_CONTEXT (x) == 0)
3468 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3476 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3479 build_conditional_expr (ifexp, op1, op2)
3480 tree ifexp, op1, op2;
3484 enum tree_code code1;
3485 enum tree_code code2;
3486 tree result_type = NULL;
3487 tree orig_op1 = op1, orig_op2 = op2;
3489 ifexp = truthvalue_conversion (default_conversion (ifexp));
3491 #if 0 /* Produces wrong result if within sizeof. */
3492 /* Don't promote the operands separately if they promote
3493 the same way. Return the unpromoted type and let the combined
3494 value get promoted if necessary. */
3496 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3497 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3498 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3499 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3501 if (TREE_CODE (ifexp) == INTEGER_CST)
3502 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3504 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3508 /* Promote both alternatives. */
3510 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3511 op1 = default_conversion (op1);
3512 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3513 op2 = default_conversion (op2);
3515 if (TREE_CODE (ifexp) == ERROR_MARK
3516 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3517 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3518 return error_mark_node;
3520 type1 = TREE_TYPE (op1);
3521 code1 = TREE_CODE (type1);
3522 type2 = TREE_TYPE (op2);
3523 code2 = TREE_CODE (type2);
3525 /* Quickly detect the usual case where op1 and op2 have the same type
3527 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3530 result_type = type1;
3532 result_type = TYPE_MAIN_VARIANT (type1);
3534 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3535 || code1 == COMPLEX_TYPE)
3536 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3537 || code2 == COMPLEX_TYPE))
3539 result_type = common_type (type1, type2);
3541 /* If -Wsign-compare, warn here if type1 and type2 have
3542 different signedness. We'll promote the signed to unsigned
3543 and later code won't know it used to be different.
3544 Do this check on the original types, so that explicit casts
3545 will be considered, but default promotions won't. */
3546 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3547 && !skip_evaluation)
3549 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3550 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3552 if (unsigned_op1 ^ unsigned_op2)
3554 /* Do not warn if the result type is signed, since the
3555 signed type will only be chosen if it can represent
3556 all the values of the unsigned type. */
3557 if (! TREE_UNSIGNED (result_type))
3559 /* Do not warn if the signed quantity is an unsuffixed
3560 integer literal (or some static constant expression
3561 involving such literals) and it is non-negative. */
3562 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3563 || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3566 warning ("signed and unsigned type in conditional expression");
3570 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3572 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3573 pedwarn ("ISO C forbids conditional expr with only one void side");
3574 result_type = void_type_node;
3576 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3578 if (comp_target_types (type1, type2))
3579 result_type = common_type (type1, type2);
3580 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3581 && TREE_CODE (orig_op1) != NOP_EXPR)
3582 result_type = qualify_type (type2, type1);
3583 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3584 && TREE_CODE (orig_op2) != NOP_EXPR)
3585 result_type = qualify_type (type1, type2);
3586 else if (VOID_TYPE_P (TREE_TYPE (type1)))
3588 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3589 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3590 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3591 TREE_TYPE (type2)));
3593 else if (VOID_TYPE_P (TREE_TYPE (type2)))
3595 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3596 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3597 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3598 TREE_TYPE (type1)));
3602 pedwarn ("pointer type mismatch in conditional expression");
3603 result_type = build_pointer_type (void_type_node);
3606 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3608 if (! integer_zerop (op2))
3609 pedwarn ("pointer/integer type mismatch in conditional expression");
3612 op2 = null_pointer_node;
3614 result_type = type1;
3616 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3618 if (!integer_zerop (op1))
3619 pedwarn ("pointer/integer type mismatch in conditional expression");
3622 op1 = null_pointer_node;
3624 result_type = type2;
3629 if (flag_cond_mismatch)
3630 result_type = void_type_node;
3633 error ("type mismatch in conditional expression");
3634 return error_mark_node;
3638 /* Merge const and volatile flags of the incoming types. */
3640 = build_type_variant (result_type,
3641 TREE_READONLY (op1) || TREE_READONLY (op2),
3642 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3644 if (result_type != TREE_TYPE (op1))
3645 op1 = convert_and_check (result_type, op1);
3646 if (result_type != TREE_TYPE (op2))
3647 op2 = convert_and_check (result_type, op2);
3649 if (TREE_CODE (ifexp) == INTEGER_CST)
3650 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3652 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3655 /* Given a list of expressions, return a compound expression
3656 that performs them all and returns the value of the last of them. */
3659 build_compound_expr (list)
3662 return internal_build_compound_expr (list, TRUE);
3666 internal_build_compound_expr (list, first_p)
3672 if (TREE_CHAIN (list) == 0)
3674 /* Convert arrays and functions to pointers when there
3675 really is a comma operator. */
3678 = default_function_array_conversion (TREE_VALUE (list));
3680 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3681 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3683 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3684 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3685 list = TREE_OPERAND (list, 0);
3688 /* Don't let (0, 0) be null pointer constant. */
3689 if (!first_p && integer_zerop (TREE_VALUE (list)))
3690 return non_lvalue (TREE_VALUE (list));
3691 return TREE_VALUE (list);
3694 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3696 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3698 /* The left-hand operand of a comma expression is like an expression
3699 statement: with -W or -Wunused, we should warn if it doesn't have
3700 any side-effects, unless it was explicitly cast to (void). */
3701 if ((extra_warnings || warn_unused_value)
3702 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3703 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3704 warning ("left-hand operand of comma expression has no effect");
3706 /* When pedantic, a compound expression can be neither an lvalue
3707 nor an integer constant expression. */
3712 /* With -Wunused, we should also warn if the left-hand operand does have
3713 side-effects, but computes a value which is not used. For example, in
3714 `foo() + bar(), baz()' the result of the `+' operator is not used,
3715 so we should issue a warning. */
3716 else if (warn_unused_value)
3717 warn_if_unused_value (TREE_VALUE (list));
3719 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3722 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3725 build_c_cast (type, expr)
3731 if (type == error_mark_node || expr == error_mark_node)
3732 return error_mark_node;
3733 type = TYPE_MAIN_VARIANT (type);
3736 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3737 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3738 value = TREE_OPERAND (value, 0);
3741 if (TREE_CODE (type) == ARRAY_TYPE)
3743 error ("cast specifies array type");
3744 return error_mark_node;
3747 if (TREE_CODE (type) == FUNCTION_TYPE)
3749 error ("cast specifies function type");
3750 return error_mark_node;
3753 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3757 if (TREE_CODE (type) == RECORD_TYPE
3758 || TREE_CODE (type) == UNION_TYPE)
3759 pedwarn ("ISO C forbids casting nonscalar to the same type");
3762 else if (TREE_CODE (type) == UNION_TYPE)
3765 value = default_function_array_conversion (value);
3767 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3768 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3769 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3778 pedwarn ("ISO C forbids casts to union type");
3779 if (TYPE_NAME (type) != 0)
3781 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3782 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3784 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3788 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3789 build_tree_list (field, value)),
3791 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3794 error ("cast to union type from type not present in union");
3795 return error_mark_node;
3801 /* If casting to void, avoid the error that would come
3802 from default_conversion in the case of a non-lvalue array. */
3803 if (type == void_type_node)
3804 return build1 (CONVERT_EXPR, type, value);
3806 /* Convert functions and arrays to pointers,
3807 but don't convert any other types. */
3808 value = default_function_array_conversion (value);
3809 otype = TREE_TYPE (value);
3811 /* Optionally warn about potentially worrisome casts. */
3814 && TREE_CODE (type) == POINTER_TYPE
3815 && TREE_CODE (otype) == POINTER_TYPE)
3817 tree in_type = type;
3818 tree in_otype = otype;
3821 /* Check that the qualifiers on IN_TYPE are a superset of
3822 the qualifiers of IN_OTYPE. The outermost level of
3823 POINTER_TYPE nodes is uninteresting and we stop as soon
3824 as we hit a non-POINTER_TYPE node on either type. */
3827 in_otype = TREE_TYPE (in_otype);
3828 in_type = TREE_TYPE (in_type);
3829 warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3831 while (TREE_CODE (in_type) == POINTER_TYPE
3832 && TREE_CODE (in_otype) == POINTER_TYPE);
3835 /* There are qualifiers present in IN_OTYPE that are not
3836 present in IN_TYPE. */
3837 warning ("cast discards qualifiers from pointer target type");
3840 /* Warn about possible alignment problems. */
3841 if (STRICT_ALIGNMENT && warn_cast_align
3842 && TREE_CODE (type) == POINTER_TYPE
3843 && TREE_CODE (otype) == POINTER_TYPE
3844 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3845 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3846 /* Don't warn about opaque types, where the actual alignment
3847 restriction is unknown. */
3848 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3849 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3850 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3851 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3852 warning ("cast increases required alignment of target type");
3854 if (TREE_CODE (type) == INTEGER_TYPE
3855 && TREE_CODE (otype) == POINTER_TYPE
3856 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3857 && !TREE_CONSTANT (value))
3858 warning ("cast from pointer to integer of different size");
3860 if (warn_bad_function_cast
3861 && TREE_CODE (value) == CALL_EXPR
3862 && TREE_CODE (type) != TREE_CODE (otype))
3863 warning ("cast does not match function type");
3865 if (TREE_CODE (type) == POINTER_TYPE
3866 && TREE_CODE (otype) == INTEGER_TYPE
3867 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3868 /* Don't warn about converting any constant. */
3869 && !TREE_CONSTANT (value))
3870 warning ("cast to pointer from integer of different size");
3873 value = convert (type, value);
3875 /* Ignore any integer overflow caused by the cast. */
3876 if (TREE_CODE (value) == INTEGER_CST)
3878 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3879 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3883 /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant. */
3884 if (pedantic && TREE_CODE (value) == INTEGER_CST
3885 && TREE_CODE (expr) == INTEGER_CST
3886 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3887 value = non_lvalue (value);
3889 /* If pedantic, don't let a cast be an lvalue. */
3890 if (value == expr && pedantic)
3891 value = non_lvalue (value);
3896 /* Interpret a cast of expression EXPR to type TYPE. */
3898 c_cast_expr (type, expr)
3901 int saved_wsp = warn_strict_prototypes;
3903 /* This avoids warnings about unprototyped casts on
3904 integers. E.g. "#define SIG_DFL (void(*)())0". */
3905 if (TREE_CODE (expr) == INTEGER_CST)
3906 warn_strict_prototypes = 0;
3907 type = groktypename (type);
3908 warn_strict_prototypes = saved_wsp;
3910 return build_c_cast (type, expr);
3914 /* Build an assignment expression of lvalue LHS from value RHS.
3915 MODIFYCODE is the code for a binary operator that we use
3916 to combine the old value of LHS with RHS to get the new value.
3917 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3920 build_modify_expr (lhs, modifycode, rhs)
3922 enum tree_code modifycode;
3926 tree lhstype = TREE_TYPE (lhs);
3927 tree olhstype = lhstype;
3929 /* Types that aren't fully specified cannot be used in assignments. */
3930 lhs = require_complete_type (lhs);
3932 /* Avoid duplicate error messages from operands that had errors. */
3933 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3934 return error_mark_node;
3936 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3937 /* Do not use STRIP_NOPS here. We do not want an enumerator
3938 whose value is 0 to count as a null pointer constant. */
3939 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3940 rhs = TREE_OPERAND (rhs, 0);
3944 /* Handle control structure constructs used as "lvalues". */
3946 switch (TREE_CODE (lhs))
3948 /* Handle (a, b) used as an "lvalue". */
3950 pedantic_lvalue_warning (COMPOUND_EXPR);
3951 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3952 if (TREE_CODE (newrhs) == ERROR_MARK)
3953 return error_mark_node;
3954 return build (COMPOUND_EXPR, lhstype,
3955 TREE_OPERAND (lhs, 0), newrhs);
3957 /* Handle (a ? b : c) used as an "lvalue". */
3959 pedantic_lvalue_warning (COND_EXPR);
3960 rhs = save_expr (rhs);
3962 /* Produce (a ? (b = rhs) : (c = rhs))
3963 except that the RHS goes through a save-expr
3964 so the code to compute it is only emitted once. */
3966 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3967 build_modify_expr (TREE_OPERAND (lhs, 1),
3969 build_modify_expr (TREE_OPERAND (lhs, 2),
3971 if (TREE_CODE (cond) == ERROR_MARK)
3973 /* Make sure the code to compute the rhs comes out
3974 before the split. */
3975 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3976 /* But cast it to void to avoid an "unused" error. */
3977 convert (void_type_node, rhs), cond);
3983 /* If a binary op has been requested, combine the old LHS value with the RHS
3984 producing the value we should actually store into the LHS. */
3986 if (modifycode != NOP_EXPR)
3988 lhs = stabilize_reference (lhs);
3989 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3992 /* Handle a cast used as an "lvalue".
3993 We have already performed any binary operator using the value as cast.
3994 Now convert the result to the cast type of the lhs,
3995 and then true type of the lhs and store it there;
3996 then convert result back to the cast type to be the value
3997 of the assignment. */
3999 switch (TREE_CODE (lhs))
4004 case FIX_TRUNC_EXPR:
4005 case FIX_FLOOR_EXPR:
4006 case FIX_ROUND_EXPR:
4008 newrhs = default_function_array_conversion (newrhs);
4010 tree inner_lhs = TREE_OPERAND (lhs, 0);
4012 result = build_modify_expr (inner_lhs, NOP_EXPR,
4013 convert (TREE_TYPE (inner_lhs),
4014 convert (lhstype, newrhs)));
4015 if (TREE_CODE (result) == ERROR_MARK)
4017 pedantic_lvalue_warning (CONVERT_EXPR);
4018 return convert (TREE_TYPE (lhs), result);
4025 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
4026 Reject anything strange now. */
4028 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
4029 return error_mark_node;
4031 /* Warn about storing in something that is `const'. */
4033 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
4034 || ((TREE_CODE (lhstype) == RECORD_TYPE
4035 || TREE_CODE (lhstype) == UNION_TYPE)
4036 && C_TYPE_FIELDS_READONLY (lhstype)))
4037 readonly_warning (lhs, "assignment");
4039 /* If storing into a structure or union member,
4040 it has probably been given type `int'.
4041 Compute the type that would go with
4042 the actual amount of storage the member occupies. */
4044 if (TREE_CODE (lhs) == COMPONENT_REF
4045 && (TREE_CODE (lhstype) == INTEGER_TYPE
4046 || TREE_CODE (lhstype) == BOOLEAN_TYPE
4047 || TREE_CODE (lhstype) == REAL_TYPE
4048 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4049 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4051 /* If storing in a field that is in actuality a short or narrower than one,
4052 we must store in the field in its actual type. */
4054 if (lhstype != TREE_TYPE (lhs))
4056 lhs = copy_node (lhs);
4057 TREE_TYPE (lhs) = lhstype;
4060 /* Convert new value to destination type. */
4062 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4063 NULL_TREE, NULL_TREE, 0);
4064 if (TREE_CODE (newrhs) == ERROR_MARK)
4065 return error_mark_node;
4069 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4070 TREE_SIDE_EFFECTS (result) = 1;
4072 /* If we got the LHS in a different type for storing in,
4073 convert the result back to the nominal type of LHS
4074 so that the value we return always has the same type
4075 as the LHS argument. */
4077 if (olhstype == TREE_TYPE (result))
4079 return convert_for_assignment (olhstype, result, _("assignment"),
4080 NULL_TREE, NULL_TREE, 0);
4083 /* Convert value RHS to type TYPE as preparation for an assignment
4084 to an lvalue of type TYPE.
4085 The real work of conversion is done by `convert'.
4086 The purpose of this function is to generate error messages
4087 for assignments that are not allowed in C.
4088 ERRTYPE is a string to use in error messages:
4089 "assignment", "return", etc. If it is null, this is parameter passing
4090 for a function call (and different error messages are output).
4092 FUNNAME is the name of the function being called,
4093 as an IDENTIFIER_NODE, or null.
4094 PARMNUM is the number of the argument, for printing in error messages. */
4097 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4099 const char *errtype;
4100 tree fundecl, funname;
4103 enum tree_code codel = TREE_CODE (type);
4105 enum tree_code coder;
4107 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4108 /* Do not use STRIP_NOPS here. We do not want an enumerator
4109 whose value is 0 to count as a null pointer constant. */
4110 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4111 rhs = TREE_OPERAND (rhs, 0);
4113 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4114 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4115 rhs = default_conversion (rhs);
4116 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4117 rhs = decl_constant_value_for_broken_optimization (rhs);
4119 rhstype = TREE_TYPE (rhs);
4120 coder = TREE_CODE (rhstype);
4122 if (coder == ERROR_MARK)
4123 return error_mark_node;
4125 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4127 overflow_warning (rhs);
4128 /* Check for Objective-C protocols. This will issue a warning if
4129 there are protocol violations. No need to use the return value. */
4130 maybe_objc_comptypes (type, rhstype, 0);
4134 if (coder == VOID_TYPE)
4136 error ("void value not ignored as it ought to be");
4137 return error_mark_node;
4139 /* A type converts to a reference to it.
4140 This code doesn't fully support references, it's just for the
4141 special case of va_start and va_copy. */
4142 if (codel == REFERENCE_TYPE
4143 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4145 if (mark_addressable (rhs) == 0)
4146 return error_mark_node;
4147 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4149 /* We already know that these two types are compatible, but they
4150 may not be exactly identical. In fact, `TREE_TYPE (type)' is
4151 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4152 likely to be va_list, a typedef to __builtin_va_list, which
4153 is different enough that it will cause problems later. */
4154 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4155 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4157 rhs = build1 (NOP_EXPR, type, rhs);
4160 /* Arithmetic types all interconvert, and enum is treated like int. */
4161 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4162 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4163 || codel == BOOLEAN_TYPE)
4164 && (coder == INTEGER_TYPE || coder == REAL_TYPE
4165 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4166 || coder == BOOLEAN_TYPE))
4167 return convert_and_check (type, rhs);
4169 /* Conversion to a transparent union from its member types.
4170 This applies only to function arguments. */
4171 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4174 tree marginal_memb_type = 0;
4176 for (memb_types = TYPE_FIELDS (type); memb_types;
4177 memb_types = TREE_CHAIN (memb_types))
4179 tree memb_type = TREE_TYPE (memb_types);
4181 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4182 TYPE_MAIN_VARIANT (rhstype)))
4185 if (TREE_CODE (memb_type) != POINTER_TYPE)
4188 if (coder == POINTER_TYPE)
4190 tree ttl = TREE_TYPE (memb_type);
4191 tree ttr = TREE_TYPE (rhstype);
4193 /* Any non-function converts to a [const][volatile] void *
4194 and vice versa; otherwise, targets must be the same.
4195 Meanwhile, the lhs target must have all the qualifiers of
4197 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4198 || comp_target_types (memb_type, rhstype))
4200 /* If this type won't generate any warnings, use it. */
4201 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4202 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4203 && TREE_CODE (ttl) == FUNCTION_TYPE)
4204 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4205 == TYPE_QUALS (ttr))
4206 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4207 == TYPE_QUALS (ttl))))
4210 /* Keep looking for a better type, but remember this one. */
4211 if (! marginal_memb_type)
4212 marginal_memb_type = memb_type;
4216 /* Can convert integer zero to any pointer type. */
4217 if (integer_zerop (rhs)
4218 || (TREE_CODE (rhs) == NOP_EXPR
4219 && integer_zerop (TREE_OPERAND (rhs, 0))))
4221 rhs = null_pointer_node;
4226 if (memb_types || marginal_memb_type)
4230 /* We have only a marginally acceptable member type;
4231 it needs a warning. */
4232 tree ttl = TREE_TYPE (marginal_memb_type);
4233 tree ttr = TREE_TYPE (rhstype);
4235 /* Const and volatile mean something different for function
4236 types, so the usual warnings are not appropriate. */
4237 if (TREE_CODE (ttr) == FUNCTION_TYPE
4238 && TREE_CODE (ttl) == FUNCTION_TYPE)
4240 /* Because const and volatile on functions are
4241 restrictions that say the function will not do
4242 certain things, it is okay to use a const or volatile
4243 function where an ordinary one is wanted, but not
4245 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4246 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4247 errtype, funname, parmnum);
4249 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4250 warn_for_assignment ("%s discards qualifiers from pointer target type",
4255 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4256 pedwarn ("ISO C prohibits argument conversion to union type");
4258 return build1 (NOP_EXPR, type, rhs);
4262 /* Conversions among pointers */
4263 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4264 && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4266 tree ttl = TREE_TYPE (type);
4267 tree ttr = TREE_TYPE (rhstype);
4269 /* Any non-function converts to a [const][volatile] void *
4270 and vice versa; otherwise, targets must be the same.
4271 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4272 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4273 || comp_target_types (type, rhstype)
4274 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4275 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4278 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4281 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4282 which are not ANSI null ptr constants. */
4283 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4284 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4285 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4286 errtype, funname, parmnum);
4287 /* Const and volatile mean something different for function types,
4288 so the usual warnings are not appropriate. */
4289 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4290 && TREE_CODE (ttl) != FUNCTION_TYPE)
4292 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4293 warn_for_assignment ("%s discards qualifiers from pointer target type",
4294 errtype, funname, parmnum);
4295 /* If this is not a case of ignoring a mismatch in signedness,
4297 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4298 || comp_target_types (type, rhstype))
4300 /* If there is a mismatch, do warn. */
4302 warn_for_assignment ("pointer targets in %s differ in signedness",
4303 errtype, funname, parmnum);
4305 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4306 && TREE_CODE (ttr) == FUNCTION_TYPE)
4308 /* Because const and volatile on functions are restrictions
4309 that say the function will not do certain things,
4310 it is okay to use a const or volatile function
4311 where an ordinary one is wanted, but not vice-versa. */
4312 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4313 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4314 errtype, funname, parmnum);
4318 warn_for_assignment ("%s from incompatible pointer type",
4319 errtype, funname, parmnum);
4320 return convert (type, rhs);
4322 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4324 /* An explicit constant 0 can convert to a pointer,
4325 or one that results from arithmetic, even including
4326 a cast to integer type. */
4327 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4329 ! (TREE_CODE (rhs) == NOP_EXPR
4330 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4331 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4332 && integer_zerop (TREE_OPERAND (rhs, 0))))
4334 warn_for_assignment ("%s makes pointer from integer without a cast",
4335 errtype, funname, parmnum);
4336 return convert (type, rhs);
4338 return null_pointer_node;
4340 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4342 warn_for_assignment ("%s makes integer from pointer without a cast",
4343 errtype, funname, parmnum);
4344 return convert (type, rhs);
4346 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4347 return convert (type, rhs);
4353 tree selector = maybe_building_objc_message_expr ();
4355 if (selector && parmnum > 2)
4356 error ("incompatible type for argument %d of `%s'",
4357 parmnum - 2, IDENTIFIER_POINTER (selector));
4359 error ("incompatible type for argument %d of `%s'",
4360 parmnum, IDENTIFIER_POINTER (funname));
4363 error ("incompatible type for argument %d of indirect function call",
4367 error ("incompatible types in %s", errtype);
4369 return error_mark_node;
4372 /* Print a warning using MSGID.
4373 It gets OPNAME as its one parameter.
4374 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4375 FUNCTION and ARGNUM are handled specially if we are building an
4376 Objective-C selector. */
4379 warn_for_assignment (msgid, opname, function, argnum)
4387 tree selector = maybe_building_objc_message_expr ();
4390 if (selector && argnum > 2)
4392 function = selector;
4397 /* Function name is known; supply it. */
4398 const char *const argstring = _("passing arg %d of `%s'");
4399 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4400 + strlen (argstring) + 1 + 25
4402 sprintf (new_opname, argstring, argnum,
4403 IDENTIFIER_POINTER (function));
4407 /* Function name unknown (call through ptr); just give arg number.*/
4408 const char *const argnofun = _("passing arg %d of pointer to function");
4409 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4410 sprintf (new_opname, argnofun, argnum);
4412 opname = new_opname;
4414 pedwarn (msgid, opname);
4417 /* If VALUE is a compound expr all of whose expressions are constant, then
4418 return its value. Otherwise, return error_mark_node.
4420 This is for handling COMPOUND_EXPRs as initializer elements
4421 which is allowed with a warning when -pedantic is specified. */
4424 valid_compound_expr_initializer (value, endtype)
4428 if (TREE_CODE (value) == COMPOUND_EXPR)
4430 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4432 return error_mark_node;
4433 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4436 else if (! TREE_CONSTANT (value)
4437 && ! initializer_constant_valid_p (value, endtype))
4438 return error_mark_node;
4443 /* Perform appropriate conversions on the initial value of a variable,
4444 store it in the declaration DECL,
4445 and print any error messages that are appropriate.
4446 If the init is invalid, store an ERROR_MARK. */
4449 store_init_value (decl, init)
4454 /* If variable's type was invalidly declared, just ignore it. */
4456 type = TREE_TYPE (decl);
4457 if (TREE_CODE (type) == ERROR_MARK)
4460 /* Digest the specified initializer into an expression. */
4462 value = digest_init (type, init, TREE_STATIC (decl),
4463 TREE_STATIC (decl) || (pedantic && !flag_isoc99));
4465 /* Store the expression if valid; else report error. */
4468 /* Note that this is the only place we can detect the error
4469 in a case such as struct foo bar = (struct foo) { x, y };
4470 where there is one initial value which is a constructor expression. */
4471 if (value == error_mark_node)
4473 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4475 error ("initializer for static variable is not constant");
4476 value = error_mark_node;
4478 else if (TREE_STATIC (decl)
4479 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4481 error ("initializer for static variable uses complicated arithmetic");
4482 value = error_mark_node;
4486 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4488 if (! TREE_CONSTANT (value))
4489 pedwarn ("aggregate initializer is not constant");
4490 else if (! TREE_STATIC (value))
4491 pedwarn ("aggregate initializer uses complicated arithmetic");
4496 if (warn_traditional && !in_system_header
4497 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4498 warning ("traditional C rejects automatic aggregate initialization");
4500 DECL_INITIAL (decl) = value;
4502 /* ANSI wants warnings about out-of-range constant initializers. */
4503 STRIP_TYPE_NOPS (value);
4504 constant_expression_warning (value);
4506 /* Check if we need to set array size from compound literal size. */
4507 if (TREE_CODE (type) == ARRAY_TYPE
4508 && TYPE_DOMAIN (type) == 0
4509 && value != error_mark_node)
4511 tree inside_init = init;
4513 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4514 inside_init = TREE_OPERAND (init, 0);
4515 inside_init = fold (inside_init);
4517 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4519 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4521 if (TYPE_DOMAIN (TREE_TYPE (decl)))
4523 /* For int foo[] = (int [3]){1}; we need to set array size
4524 now since later on array initializer will be just the
4525 brace enclosed list of the compound literal. */
4526 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
4528 layout_decl (decl, 0);
4534 /* Methods for storing and printing names for error messages. */
4536 /* Implement a spelling stack that allows components of a name to be pushed
4537 and popped. Each element on the stack is this structure. */
4549 #define SPELLING_STRING 1
4550 #define SPELLING_MEMBER 2
4551 #define SPELLING_BOUNDS 3
4553 static struct spelling *spelling; /* Next stack element (unused). */
4554 static struct spelling *spelling_base; /* Spelling stack base. */
4555 static int spelling_size; /* Size of the spelling stack. */
4557 /* Macros to save and restore the spelling stack around push_... functions.
4558 Alternative to SAVE_SPELLING_STACK. */
4560 #define SPELLING_DEPTH() (spelling - spelling_base)
4561 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4563 /* Save and restore the spelling stack around arbitrary C code. */
4565 #define SAVE_SPELLING_DEPTH(code) \
4567 int __depth = SPELLING_DEPTH (); \
4569 RESTORE_SPELLING_DEPTH (__depth); \
4572 /* Push an element on the spelling stack with type KIND and assign VALUE
4575 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4577 int depth = SPELLING_DEPTH (); \
4579 if (depth >= spelling_size) \
4581 spelling_size += 10; \
4582 if (spelling_base == 0) \
4584 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4587 = (struct spelling *) xrealloc (spelling_base, \
4588 spelling_size * sizeof (struct spelling)); \
4589 RESTORE_SPELLING_DEPTH (depth); \
4592 spelling->kind = (KIND); \
4593 spelling->MEMBER = (VALUE); \
4597 /* Push STRING on the stack. Printed literally. */
4600 push_string (string)
4603 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4606 /* Push a member name on the stack. Printed as '.' STRING. */
4609 push_member_name (decl)
4613 const char *const string
4614 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4615 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4618 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4621 push_array_bounds (bounds)
4624 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4627 /* Compute the maximum size in bytes of the printed spelling. */
4635 for (p = spelling_base; p < spelling; p++)
4637 if (p->kind == SPELLING_BOUNDS)
4640 size += strlen (p->u.s) + 1;
4646 /* Print the spelling to BUFFER and return it. */
4649 print_spelling (buffer)
4655 for (p = spelling_base; p < spelling; p++)
4656 if (p->kind == SPELLING_BOUNDS)
4658 sprintf (d, "[%d]", p->u.i);
4664 if (p->kind == SPELLING_MEMBER)
4666 for (s = p->u.s; (*d = *s++); d++)
4673 /* Issue an error message for a bad initializer component.
4674 MSGID identifies the message.
4675 The component name is taken from the spelling stack. */
4683 error ("%s", _(msgid));
4684 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4686 error ("(near initialization for `%s')", ofwhat);
4689 /* Issue a pedantic warning for a bad initializer component.
4690 MSGID identifies the message.
4691 The component name is taken from the spelling stack. */
4694 pedwarn_init (msgid)
4699 pedwarn ("%s", _(msgid));
4700 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4702 pedwarn ("(near initialization for `%s')", ofwhat);
4705 /* Issue a warning for a bad initializer component.
4706 MSGID identifies the message.
4707 The component name is taken from the spelling stack. */
4710 warning_init (msgid)
4715 warning ("%s", _(msgid));
4716 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4718 warning ("(near initialization for `%s')", ofwhat);
4721 /* Digest the parser output INIT as an initializer for type TYPE.
4722 Return a C expression of type TYPE to represent the initial value.
4724 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4725 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4726 applies only to elements of constructors. */
4729 digest_init (type, init, require_constant, constructor_constant)
4731 int require_constant, constructor_constant;
4733 enum tree_code code = TREE_CODE (type);
4734 tree inside_init = init;
4736 if (type == error_mark_node
4737 || init == error_mark_node
4738 || TREE_TYPE (init) == error_mark_node)
4739 return error_mark_node;
4741 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4742 /* Do not use STRIP_NOPS here. We do not want an enumerator
4743 whose value is 0 to count as a null pointer constant. */
4744 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4745 inside_init = TREE_OPERAND (init, 0);
4747 inside_init = fold (inside_init);
4749 /* Initialization of an array of chars from a string constant
4750 optionally enclosed in braces. */
4752 if (code == ARRAY_TYPE)
4754 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4755 if ((typ1 == char_type_node
4756 || typ1 == signed_char_type_node
4757 || typ1 == unsigned_char_type_node
4758 || typ1 == unsigned_wchar_type_node
4759 || typ1 == signed_wchar_type_node)
4760 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4762 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4763 TYPE_MAIN_VARIANT (type)))
4766 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4768 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4770 error_init ("char-array initialized from wide string");
4771 return error_mark_node;
4773 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4775 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4777 error_init ("int-array initialized from non-wide string");
4778 return error_mark_node;
4781 TREE_TYPE (inside_init) = type;
4782 if (TYPE_DOMAIN (type) != 0
4783 && TYPE_SIZE (type) != 0
4784 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4785 /* Subtract 1 (or sizeof (wchar_t))
4786 because it's ok to ignore the terminating null char
4787 that is counted in the length of the constant. */
4788 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4789 TREE_STRING_LENGTH (inside_init)
4790 - ((TYPE_PRECISION (typ1)
4791 != TYPE_PRECISION (char_type_node))
4792 ? (TYPE_PRECISION (wchar_type_node)
4795 pedwarn_init ("initializer-string for array of chars is too long");
4801 /* Any type can be initialized
4802 from an expression of the same type, optionally with braces. */
4804 if (inside_init && TREE_TYPE (inside_init) != 0
4805 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4806 TYPE_MAIN_VARIANT (type))
4807 || (code == ARRAY_TYPE
4808 && comptypes (TREE_TYPE (inside_init), type))
4809 || (code == POINTER_TYPE
4810 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4811 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4812 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4813 TREE_TYPE (type)))))
4815 if (code == POINTER_TYPE)
4816 inside_init = default_function_array_conversion (inside_init);
4818 if (require_constant && !flag_isoc99
4819 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4821 /* As an extension, allow initializing objects with static storage
4822 duration with compound literals (which are then treated just as
4823 the brace enclosed list they contain). */
4824 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4825 inside_init = DECL_INITIAL (decl);
4828 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4829 && TREE_CODE (inside_init) != CONSTRUCTOR)
4831 error_init ("array initialized from non-constant array expression");
4832 return error_mark_node;
4835 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4836 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4838 /* Compound expressions can only occur here if -pedantic or
4839 -pedantic-errors is specified. In the later case, we always want
4840 an error. In the former case, we simply want a warning. */
4841 if (require_constant && pedantic
4842 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4845 = valid_compound_expr_initializer (inside_init,
4846 TREE_TYPE (inside_init));
4847 if (inside_init == error_mark_node)
4848 error_init ("initializer element is not constant");
4850 pedwarn_init ("initializer element is not constant");
4851 if (flag_pedantic_errors)
4852 inside_init = error_mark_node;
4854 else if (require_constant
4855 && (!TREE_CONSTANT (inside_init)
4856 /* This test catches things like `7 / 0' which
4857 result in an expression for which TREE_CONSTANT
4858 is true, but which is not actually something
4859 that is a legal constant. We really should not
4860 be using this function, because it is a part of
4861 the back-end. Instead, the expression should
4862 already have been turned into ERROR_MARK_NODE. */
4863 || !initializer_constant_valid_p (inside_init,
4864 TREE_TYPE (inside_init))))
4866 error_init ("initializer element is not constant");
4867 inside_init = error_mark_node;
4873 /* Handle scalar types, including conversions. */
4875 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4876 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4878 /* Note that convert_for_assignment calls default_conversion
4879 for arrays and functions. We must not call it in the
4880 case where inside_init is a null pointer constant. */
4882 = convert_for_assignment (type, init, _("initialization"),
4883 NULL_TREE, NULL_TREE, 0);
4885 if (require_constant && ! TREE_CONSTANT (inside_init))
4887 error_init ("initializer element is not constant");
4888 inside_init = error_mark_node;
4890 else if (require_constant
4891 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4893 error_init ("initializer element is not computable at load time");
4894 inside_init = error_mark_node;
4900 /* Come here only for records and arrays. */
4902 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4904 error_init ("variable-sized object may not be initialized");
4905 return error_mark_node;
4908 /* Traditionally, you can write struct foo x = 0;
4909 and it initializes the first element of x to 0. */
4910 if (flag_traditional)
4912 tree top = 0, prev = 0, otype = type;
4913 while (TREE_CODE (type) == RECORD_TYPE
4914 || TREE_CODE (type) == ARRAY_TYPE
4915 || TREE_CODE (type) == QUAL_UNION_TYPE
4916 || TREE_CODE (type) == UNION_TYPE)
4918 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4922 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4924 if (TREE_CODE (type) == ARRAY_TYPE)
4925 type = TREE_TYPE (type);
4926 else if (TYPE_FIELDS (type))
4927 type = TREE_TYPE (TYPE_FIELDS (type));
4930 error_init ("invalid initializer");
4931 return error_mark_node;
4937 TREE_OPERAND (prev, 1)
4938 = build_tree_list (NULL_TREE,
4939 digest_init (type, init, require_constant,
4940 constructor_constant));
4944 return error_mark_node;
4946 error_init ("invalid initializer");
4947 return error_mark_node;
4950 /* Handle initializers that use braces. */
4952 /* Type of object we are accumulating a constructor for.
4953 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4954 static tree constructor_type;
4956 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4958 static tree constructor_fields;
4960 /* For an ARRAY_TYPE, this is the specified index
4961 at which to store the next element we get. */
4962 static tree constructor_index;
4964 /* For an ARRAY_TYPE, this is the maximum index. */
4965 static tree constructor_max_index;
4967 /* For a RECORD_TYPE, this is the first field not yet written out. */
4968 static tree constructor_unfilled_fields;
4970 /* For an ARRAY_TYPE, this is the index of the first element
4971 not yet written out. */
4972 static tree constructor_unfilled_index;
4974 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4975 This is so we can generate gaps between fields, when appropriate. */
4976 static tree constructor_bit_index;
4978 /* If we are saving up the elements rather than allocating them,
4979 this is the list of elements so far (in reverse order,
4980 most recent first). */
4981 static tree constructor_elements;
4983 /* 1 if constructor should be incrementally stored into a constructor chain,
4984 0 if all the elements should be kept in AVL tree. */
4985 static int constructor_incremental;
4987 /* 1 if so far this constructor's elements are all compile-time constants. */
4988 static int constructor_constant;
4990 /* 1 if so far this constructor's elements are all valid address constants. */
4991 static int constructor_simple;
4993 /* 1 if this constructor is erroneous so far. */
4994 static int constructor_erroneous;
4996 /* 1 if have called defer_addressed_constants. */
4997 static int constructor_subconstants_deferred;
4999 /* Structure for managing pending initializer elements, organized as an
5004 struct init_node *left, *right;
5005 struct init_node *parent;
5011 /* Tree of pending elements at this constructor level.
5012 These are elements encountered out of order
5013 which belong at places we haven't reached yet in actually
5015 Will never hold tree nodes across GC runs. */
5016 static struct init_node *constructor_pending_elts;
5018 /* The SPELLING_DEPTH of this constructor. */
5019 static int constructor_depth;
5021 /* 0 if implicitly pushing constructor levels is allowed. */
5022 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
5024 static int require_constant_value;
5025 static int require_constant_elements;
5027 /* DECL node for which an initializer is being read.
5028 0 means we are reading a constructor expression
5029 such as (struct foo) {...}. */
5030 static tree constructor_decl;
5032 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
5033 static const char *constructor_asmspec;
5035 /* Nonzero if this is an initializer for a top-level decl. */
5036 static int constructor_top_level;
5038 /* Nonzero if there were any member designators in this initializer. */
5039 static int constructor_designated;
5041 /* Nesting depth of designator list. */
5042 static int designator_depth;
5044 /* Nonzero if there were diagnosed errors in this designator list. */
5045 static int designator_errorneous;
5048 /* This stack has a level for each implicit or explicit level of
5049 structuring in the initializer, including the outermost one. It
5050 saves the values of most of the variables above. */
5052 struct constructor_range_stack;
5054 struct constructor_stack
5056 struct constructor_stack *next;
5061 tree unfilled_index;
5062 tree unfilled_fields;
5065 struct init_node *pending_elts;
5068 /* If nonzero, this value should replace the entire
5069 constructor at this level. */
5070 tree replacement_value;
5071 struct constructor_range_stack *range_stack;
5081 struct constructor_stack *constructor_stack;
5083 /* This stack represents designators from some range designator up to
5084 the last designator in the list. */
5086 struct constructor_range_stack
5088 struct constructor_range_stack *next, *prev;
5089 struct constructor_stack *stack;
5096 struct constructor_range_stack *constructor_range_stack;
5098 /* This stack records separate initializers that are nested.
5099 Nested initializers can't happen in ANSI C, but GNU C allows them
5100 in cases like { ... (struct foo) { ... } ... }. */
5102 struct initializer_stack
5104 struct initializer_stack *next;
5106 const char *asmspec;
5107 struct constructor_stack *constructor_stack;
5108 struct constructor_range_stack *constructor_range_stack;
5110 struct spelling *spelling;
5111 struct spelling *spelling_base;
5114 char require_constant_value;
5115 char require_constant_elements;
5119 struct initializer_stack *initializer_stack;
5121 /* Prepare to parse and output the initializer for variable DECL. */
5124 start_init (decl, asmspec_tree, top_level)
5130 struct initializer_stack *p
5131 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5132 const char *asmspec = 0;
5135 asmspec = TREE_STRING_POINTER (asmspec_tree);
5137 p->decl = constructor_decl;
5138 p->asmspec = constructor_asmspec;
5139 p->require_constant_value = require_constant_value;
5140 p->require_constant_elements = require_constant_elements;
5141 p->constructor_stack = constructor_stack;
5142 p->constructor_range_stack = constructor_range_stack;
5143 p->elements = constructor_elements;
5144 p->spelling = spelling;
5145 p->spelling_base = spelling_base;
5146 p->spelling_size = spelling_size;
5147 p->deferred = constructor_subconstants_deferred;
5148 p->top_level = constructor_top_level;
5149 p->next = initializer_stack;
5150 initializer_stack = p;
5152 constructor_decl = decl;
5153 constructor_asmspec = asmspec;
5154 constructor_subconstants_deferred = 0;
5155 constructor_designated = 0;
5156 constructor_top_level = top_level;
5160 require_constant_value = TREE_STATIC (decl);
5161 require_constant_elements
5162 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5163 /* For a scalar, you can always use any value to initialize,
5164 even within braces. */
5165 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5166 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5167 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5168 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5169 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5173 require_constant_value = 0;
5174 require_constant_elements = 0;
5175 locus = "(anonymous)";
5178 constructor_stack = 0;
5179 constructor_range_stack = 0;
5181 missing_braces_mentioned = 0;
5185 RESTORE_SPELLING_DEPTH (0);
5188 push_string (locus);
5194 struct initializer_stack *p = initializer_stack;
5196 /* Output subconstants (string constants, usually)
5197 that were referenced within this initializer and saved up.
5198 Must do this if and only if we called defer_addressed_constants. */
5199 if (constructor_subconstants_deferred)
5200 output_deferred_addressed_constants ();
5202 /* Free the whole constructor stack of this initializer. */
5203 while (constructor_stack)
5205 struct constructor_stack *q = constructor_stack;
5206 constructor_stack = q->next;
5210 if (constructor_range_stack)
5213 /* Pop back to the data of the outer initializer (if any). */
5214 constructor_decl = p->decl;
5215 constructor_asmspec = p->asmspec;
5216 require_constant_value = p->require_constant_value;
5217 require_constant_elements = p->require_constant_elements;
5218 constructor_stack = p->constructor_stack;
5219 constructor_range_stack = p->constructor_range_stack;
5220 constructor_elements = p->elements;
5221 spelling = p->spelling;
5222 spelling_base = p->spelling_base;
5223 spelling_size = p->spelling_size;
5224 constructor_subconstants_deferred = p->deferred;
5225 constructor_top_level = p->top_level;
5226 initializer_stack = p->next;
5230 /* Call here when we see the initializer is surrounded by braces.
5231 This is instead of a call to push_init_level;
5232 it is matched by a call to pop_init_level.
5234 TYPE is the type to initialize, for a constructor expression.
5235 For an initializer for a decl, TYPE is zero. */
5238 really_start_incremental_init (type)
5241 struct constructor_stack *p
5242 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5245 type = TREE_TYPE (constructor_decl);
5247 p->type = constructor_type;
5248 p->fields = constructor_fields;
5249 p->index = constructor_index;
5250 p->max_index = constructor_max_index;
5251 p->unfilled_index = constructor_unfilled_index;
5252 p->unfilled_fields = constructor_unfilled_fields;
5253 p->bit_index = constructor_bit_index;
5254 p->elements = constructor_elements;
5255 p->constant = constructor_constant;
5256 p->simple = constructor_simple;
5257 p->erroneous = constructor_erroneous;
5258 p->pending_elts = constructor_pending_elts;
5259 p->depth = constructor_depth;
5260 p->replacement_value = 0;
5264 p->incremental = constructor_incremental;
5265 p->designated = constructor_designated;
5267 constructor_stack = p;
5269 constructor_constant = 1;
5270 constructor_simple = 1;
5271 constructor_depth = SPELLING_DEPTH ();
5272 constructor_elements = 0;
5273 constructor_pending_elts = 0;
5274 constructor_type = type;
5275 constructor_incremental = 1;
5276 constructor_designated = 0;
5277 designator_depth = 0;
5278 designator_errorneous = 0;
5280 if (TREE_CODE (constructor_type) == RECORD_TYPE
5281 || TREE_CODE (constructor_type) == UNION_TYPE)
5283 constructor_fields = TYPE_FIELDS (constructor_type);
5284 /* Skip any nameless bit fields at the beginning. */
5285 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5286 && DECL_NAME (constructor_fields) == 0)
5287 constructor_fields = TREE_CHAIN (constructor_fields);
5289 constructor_unfilled_fields = constructor_fields;
5290 constructor_bit_index = bitsize_zero_node;
5292 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5294 if (TYPE_DOMAIN (constructor_type))
5296 constructor_max_index
5297 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5299 /* Detect non-empty initializations of zero-length arrays. */
5300 if (constructor_max_index == NULL_TREE
5301 && TYPE_SIZE (constructor_type))
5302 constructor_max_index = build_int_2 (-1, -1);
5304 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5305 to initialize VLAs will cause an proper error; avoid tree
5306 checking errors as well by setting a safe value. */
5307 if (constructor_max_index
5308 && TREE_CODE (constructor_max_index) != INTEGER_CST)
5309 constructor_max_index = build_int_2 (-1, -1);
5312 = convert (bitsizetype,
5313 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5316 constructor_index = bitsize_zero_node;
5318 constructor_unfilled_index = constructor_index;
5322 /* Handle the case of int x = {5}; */
5323 constructor_fields = constructor_type;
5324 constructor_unfilled_fields = constructor_type;
5328 /* Push down into a subobject, for initialization.
5329 If this is for an explicit set of braces, IMPLICIT is 0.
5330 If it is because the next element belongs at a lower level,
5331 IMPLICIT is 1 (or 2 if the push is because of designator list). */
5334 push_init_level (implicit)
5337 struct constructor_stack *p;
5338 tree value = NULL_TREE;
5340 /* If we've exhausted any levels that didn't have braces,
5342 while (constructor_stack->implicit)
5344 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5345 || TREE_CODE (constructor_type) == UNION_TYPE)
5346 && constructor_fields == 0)
5347 process_init_element (pop_init_level (1));
5348 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5349 && tree_int_cst_lt (constructor_max_index, constructor_index))
5350 process_init_element (pop_init_level (1));
5355 /* Unless this is an explicit brace, we need to preserve previous
5359 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5360 || TREE_CODE (constructor_type) == UNION_TYPE)
5361 && constructor_fields)
5362 value = find_init_member (constructor_fields);
5363 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5364 value = find_init_member (constructor_index);
5367 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5368 p->type = constructor_type;
5369 p->fields = constructor_fields;
5370 p->index = constructor_index;
5371 p->max_index = constructor_max_index;
5372 p->unfilled_index = constructor_unfilled_index;
5373 p->unfilled_fields = constructor_unfilled_fields;
5374 p->bit_index = constructor_bit_index;
5375 p->elements = constructor_elements;
5376 p->constant = constructor_constant;
5377 p->simple = constructor_simple;
5378 p->erroneous = constructor_erroneous;
5379 p->pending_elts = constructor_pending_elts;
5380 p->depth = constructor_depth;
5381 p->replacement_value = 0;
5382 p->implicit = implicit;
5384 p->incremental = constructor_incremental;
5385 p->designated = constructor_designated;
5386 p->next = constructor_stack;
5388 constructor_stack = p;
5390 constructor_constant = 1;
5391 constructor_simple = 1;
5392 constructor_depth = SPELLING_DEPTH ();
5393 constructor_elements = 0;
5394 constructor_incremental = 1;
5395 constructor_designated = 0;
5396 constructor_pending_elts = 0;
5399 p->range_stack = constructor_range_stack;
5400 constructor_range_stack = 0;
5401 designator_depth = 0;
5402 designator_errorneous = 0;
5405 /* Don't die if an entire brace-pair level is superfluous
5406 in the containing level. */
5407 if (constructor_type == 0)
5409 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5410 || TREE_CODE (constructor_type) == UNION_TYPE)
5412 /* Don't die if there are extra init elts at the end. */
5413 if (constructor_fields == 0)
5414 constructor_type = 0;
5417 constructor_type = TREE_TYPE (constructor_fields);
5418 push_member_name (constructor_fields);
5419 constructor_depth++;
5422 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5424 constructor_type = TREE_TYPE (constructor_type);
5425 push_array_bounds (tree_low_cst (constructor_index, 0));
5426 constructor_depth++;
5429 if (constructor_type == 0)
5431 error_init ("extra brace group at end of initializer");
5432 constructor_fields = 0;
5433 constructor_unfilled_fields = 0;
5437 if (value && TREE_CODE (value) == CONSTRUCTOR)
5439 constructor_constant = TREE_CONSTANT (value);
5440 constructor_simple = TREE_STATIC (value);
5441 constructor_elements = TREE_OPERAND (value, 1);
5442 if (constructor_elements
5443 && (TREE_CODE (constructor_type) == RECORD_TYPE
5444 || TREE_CODE (constructor_type) == ARRAY_TYPE))
5445 set_nonincremental_init ();
5448 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5450 missing_braces_mentioned = 1;
5451 warning_init ("missing braces around initializer");
5454 if (TREE_CODE (constructor_type) == RECORD_TYPE
5455 || TREE_CODE (constructor_type) == UNION_TYPE)
5457 constructor_fields = TYPE_FIELDS (constructor_type);
5458 /* Skip any nameless bit fields at the beginning. */
5459 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5460 && DECL_NAME (constructor_fields) == 0)
5461 constructor_fields = TREE_CHAIN (constructor_fields);
5463 constructor_unfilled_fields = constructor_fields;
5464 constructor_bit_index = bitsize_zero_node;
5466 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5468 if (TYPE_DOMAIN (constructor_type))
5470 constructor_max_index
5471 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5473 /* Detect non-empty initializations of zero-length arrays. */
5474 if (constructor_max_index == NULL_TREE
5475 && TYPE_SIZE (constructor_type))
5476 constructor_max_index = build_int_2 (-1, -1);
5478 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5479 to initialize VLAs will cause an proper error; avoid tree
5480 checking errors as well by setting a safe value. */
5481 if (constructor_max_index
5482 && TREE_CODE (constructor_max_index) != INTEGER_CST)
5483 constructor_max_index = build_int_2 (-1, -1);
5486 = convert (bitsizetype,
5487 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5490 constructor_index = bitsize_zero_node;
5492 constructor_unfilled_index = constructor_index;
5493 if (value && TREE_CODE (value) == STRING_CST)
5495 /* We need to split the char/wchar array into individual
5496 characters, so that we don't have to special case it
5498 set_nonincremental_init_from_string (value);
5503 warning_init ("braces around scalar initializer");
5504 constructor_fields = constructor_type;
5505 constructor_unfilled_fields = constructor_type;
5509 /* At the end of an implicit or explicit brace level,
5510 finish up that level of constructor.
5511 If we were outputting the elements as they are read, return 0
5512 from inner levels (process_init_element ignores that),
5513 but return error_mark_node from the outermost level
5514 (that's what we want to put in DECL_INITIAL).
5515 Otherwise, return a CONSTRUCTOR expression. */
5518 pop_init_level (implicit)
5521 struct constructor_stack *p;
5522 tree constructor = 0;
5526 /* When we come to an explicit close brace,
5527 pop any inner levels that didn't have explicit braces. */
5528 while (constructor_stack->implicit)
5529 process_init_element (pop_init_level (1));
5531 if (constructor_range_stack)
5535 p = constructor_stack;
5537 /* Error for initializing a flexible array member, or a zero-length
5538 array member in an inappropriate context. */
5539 if (constructor_type && constructor_fields
5540 && TREE_CODE (constructor_type) == ARRAY_TYPE
5541 && TYPE_DOMAIN (constructor_type)
5542 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5544 /* Silently discard empty initializations. The parser will
5545 already have pedwarned for empty brackets. */
5546 if (integer_zerop (constructor_unfilled_index))
5547 constructor_type = NULL_TREE;
5548 else if (! TYPE_SIZE (constructor_type))
5550 if (constructor_depth > 2)
5551 error_init ("initialization of flexible array member in a nested context");
5553 pedwarn_init ("initialization of a flexible array member");
5555 /* We have already issued an error message for the existence
5556 of a flexible array member not at the end of the structure.
5557 Discard the initializer so that we do not abort later. */
5558 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5559 constructor_type = NULL_TREE;
5562 /* Zero-length arrays are no longer special, so we should no longer
5567 /* Warn when some struct elements are implicitly initialized to zero. */
5570 && TREE_CODE (constructor_type) == RECORD_TYPE
5571 && constructor_unfilled_fields)
5573 /* Do not warn for flexible array members or zero-length arrays. */
5574 while (constructor_unfilled_fields
5575 && (! DECL_SIZE (constructor_unfilled_fields)
5576 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5577 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5579 /* Do not warn if this level of the initializer uses member
5580 designators; it is likely to be deliberate. */
5581 if (constructor_unfilled_fields && !constructor_designated)
5583 push_member_name (constructor_unfilled_fields);
5584 warning_init ("missing initializer");
5585 RESTORE_SPELLING_DEPTH (constructor_depth);
5589 /* Now output all pending elements. */
5590 constructor_incremental = 1;
5591 output_pending_init_elements (1);
5593 /* Pad out the end of the structure. */
5594 if (p->replacement_value)
5595 /* If this closes a superfluous brace pair,
5596 just pass out the element between them. */
5597 constructor = p->replacement_value;
5598 else if (constructor_type == 0)
5600 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5601 && TREE_CODE (constructor_type) != UNION_TYPE
5602 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5604 /* A nonincremental scalar initializer--just return
5605 the element, after verifying there is just one. */
5606 if (constructor_elements == 0)
5608 if (!constructor_erroneous)
5609 error_init ("empty scalar initializer");
5610 constructor = error_mark_node;
5612 else if (TREE_CHAIN (constructor_elements) != 0)
5614 error_init ("extra elements in scalar initializer");
5615 constructor = TREE_VALUE (constructor_elements);
5618 constructor = TREE_VALUE (constructor_elements);
5622 if (constructor_erroneous)
5623 constructor = error_mark_node;
5626 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5627 nreverse (constructor_elements));
5628 if (constructor_constant)
5629 TREE_CONSTANT (constructor) = 1;
5630 if (constructor_constant && constructor_simple)
5631 TREE_STATIC (constructor) = 1;
5635 constructor_type = p->type;
5636 constructor_fields = p->fields;
5637 constructor_index = p->index;
5638 constructor_max_index = p->max_index;
5639 constructor_unfilled_index = p->unfilled_index;
5640 constructor_unfilled_fields = p->unfilled_fields;
5641 constructor_bit_index = p->bit_index;
5642 constructor_elements = p->elements;
5643 constructor_constant = p->constant;
5644 constructor_simple = p->simple;
5645 constructor_erroneous = p->erroneous;
5646 constructor_incremental = p->incremental;
5647 constructor_designated = p->designated;
5648 constructor_pending_elts = p->pending_elts;
5649 constructor_depth = p->depth;
5651 constructor_range_stack = p->range_stack;
5652 RESTORE_SPELLING_DEPTH (constructor_depth);
5654 constructor_stack = p->next;
5657 if (constructor == 0)
5659 if (constructor_stack == 0)
5660 return error_mark_node;
5666 /* Common handling for both array range and field name designators.
5667 ARRAY argument is non-zero for array ranges. Returns zero for success. */
5670 set_designator (array)
5674 enum tree_code subcode;
5676 /* Don't die if an entire brace-pair level is superfluous
5677 in the containing level. */
5678 if (constructor_type == 0)
5681 /* If there were errors in this designator list already, bail out silently. */
5682 if (designator_errorneous)
5685 if (!designator_depth)
5687 if (constructor_range_stack)
5690 /* Designator list starts at the level of closest explicit
5692 while (constructor_stack->implicit)
5693 process_init_element (pop_init_level (1));
5694 constructor_designated = 1;
5698 if (constructor_no_implicit)
5700 error_init ("initialization designators may not nest");
5704 if (TREE_CODE (constructor_type) == RECORD_TYPE
5705 || TREE_CODE (constructor_type) == UNION_TYPE)
5707 subtype = TREE_TYPE (constructor_fields);
5708 if (subtype != error_mark_node)
5709 subtype = TYPE_MAIN_VARIANT (subtype);
5711 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5713 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5718 subcode = TREE_CODE (subtype);
5719 if (array && subcode != ARRAY_TYPE)
5721 error_init ("array index in non-array initializer");
5724 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5726 error_init ("field name not in record or union initializer");
5730 constructor_designated = 1;
5731 push_init_level (2);
5735 /* If there are range designators in designator list, push a new designator
5736 to constructor_range_stack. RANGE_END is end of such stack range or
5737 NULL_TREE if there is no range designator at this level. */
5740 push_range_stack (range_end)
5743 struct constructor_range_stack *p;
5745 p = (struct constructor_range_stack *)
5746 ggc_alloc (sizeof (struct constructor_range_stack));
5747 p->prev = constructor_range_stack;
5749 p->fields = constructor_fields;
5750 p->range_start = constructor_index;
5751 p->index = constructor_index;
5752 p->stack = constructor_stack;
5753 p->range_end = range_end;
5754 if (constructor_range_stack)
5755 constructor_range_stack->next = p;
5756 constructor_range_stack = p;
5759 /* Within an array initializer, specify the next index to be initialized.
5760 FIRST is that index. If LAST is nonzero, then initialize a range
5761 of indices, running from FIRST through LAST. */
5764 set_init_index (first, last)
5767 if (set_designator (1))
5770 designator_errorneous = 1;
5772 while ((TREE_CODE (first) == NOP_EXPR
5773 || TREE_CODE (first) == CONVERT_EXPR
5774 || TREE_CODE (first) == NON_LVALUE_EXPR)
5775 && (TYPE_MODE (TREE_TYPE (first))
5776 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5777 first = TREE_OPERAND (first, 0);
5780 while ((TREE_CODE (last) == NOP_EXPR
5781 || TREE_CODE (last) == CONVERT_EXPR
5782 || TREE_CODE (last) == NON_LVALUE_EXPR)
5783 && (TYPE_MODE (TREE_TYPE (last))
5784 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5785 last = TREE_OPERAND (last, 0);
5787 if (TREE_CODE (first) != INTEGER_CST)
5788 error_init ("nonconstant array index in initializer");
5789 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5790 error_init ("nonconstant array index in initializer");
5791 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5792 error_init ("array index in non-array initializer");
5793 else if (constructor_max_index
5794 && tree_int_cst_lt (constructor_max_index, first))
5795 error_init ("array index in initializer exceeds array bounds");
5798 constructor_index = convert (bitsizetype, first);
5802 if (tree_int_cst_equal (first, last))
5804 else if (tree_int_cst_lt (last, first))
5806 error_init ("empty index range in initializer");
5811 last = convert (bitsizetype, last);
5812 if (constructor_max_index != 0
5813 && tree_int_cst_lt (constructor_max_index, last))
5815 error_init ("array index range in initializer exceeds array bounds");
5822 designator_errorneous = 0;
5823 if (constructor_range_stack || last)
5824 push_range_stack (last);
5828 /* Within a struct initializer, specify the next field to be initialized. */
5831 set_init_label (fieldname)
5836 if (set_designator (0))
5839 designator_errorneous = 1;
5841 if (TREE_CODE (constructor_type) != RECORD_TYPE
5842 && TREE_CODE (constructor_type) != UNION_TYPE)
5844 error_init ("field name not in record or union initializer");
5848 for (tail = TYPE_FIELDS (constructor_type); tail;
5849 tail = TREE_CHAIN (tail))
5851 if (DECL_NAME (tail) == fieldname)
5856 error ("unknown field `%s' specified in initializer",
5857 IDENTIFIER_POINTER (fieldname));
5860 constructor_fields = tail;
5862 designator_errorneous = 0;
5863 if (constructor_range_stack)
5864 push_range_stack (NULL_TREE);
5868 /* Add a new initializer to the tree of pending initializers. PURPOSE
5869 identifies the initializer, either array index or field in a structure.
5870 VALUE is the value of that index or field. */
5873 add_pending_init (purpose, value)
5874 tree purpose, value;
5876 struct init_node *p, **q, *r;
5878 q = &constructor_pending_elts;
5881 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5886 if (tree_int_cst_lt (purpose, p->purpose))
5888 else if (tree_int_cst_lt (p->purpose, purpose))
5892 if (TREE_SIDE_EFFECTS (p->value))
5893 warning_init ("initialized field with side-effects overwritten");
5903 bitpos = bit_position (purpose);
5907 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5909 else if (p->purpose != purpose)
5913 if (TREE_SIDE_EFFECTS (p->value))
5914 warning_init ("initialized field with side-effects overwritten");
5921 r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5922 r->purpose = purpose;
5933 struct init_node *s;
5937 if (p->balance == 0)
5939 else if (p->balance < 0)
5946 p->left->parent = p;
5963 constructor_pending_elts = r;
5968 struct init_node *t = r->right;
5972 r->right->parent = r;
5977 p->left->parent = p;
5980 p->balance = t->balance < 0;
5981 r->balance = -(t->balance > 0);
5996 constructor_pending_elts = t;
6002 /* p->balance == +1; growth of left side balances the node. */
6007 else /* r == p->right */
6009 if (p->balance == 0)
6010 /* Growth propagation from right side. */
6012 else if (p->balance > 0)
6019 p->right->parent = p;
6036 constructor_pending_elts = r;
6038 else /* r->balance == -1 */
6041 struct init_node *t = r->left;
6045 r->left->parent = r;
6050 p->right->parent = p;
6053 r->balance = (t->balance < 0);
6054 p->balance = -(t->balance > 0);
6069 constructor_pending_elts = t;
6075 /* p->balance == -1; growth of right side balances the node. */
6086 /* Build AVL tree from a sorted chain. */
6089 set_nonincremental_init ()
6093 if (TREE_CODE (constructor_type) != RECORD_TYPE
6094 && TREE_CODE (constructor_type) != ARRAY_TYPE)
6097 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
6098 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
6099 constructor_elements = 0;
6100 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6102 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6103 /* Skip any nameless bit fields at the beginning. */
6104 while (constructor_unfilled_fields != 0
6105 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6106 && DECL_NAME (constructor_unfilled_fields) == 0)
6107 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6110 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6112 if (TYPE_DOMAIN (constructor_type))
6113 constructor_unfilled_index
6114 = convert (bitsizetype,
6115 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6117 constructor_unfilled_index = bitsize_zero_node;
6119 constructor_incremental = 0;
6122 /* Build AVL tree from a string constant. */
6125 set_nonincremental_init_from_string (str)
6128 tree value, purpose, type;
6129 HOST_WIDE_INT val[2];
6130 const char *p, *end;
6131 int byte, wchar_bytes, charwidth, bitpos;
6133 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6136 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6137 == TYPE_PRECISION (char_type_node))
6139 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6140 == TYPE_PRECISION (wchar_type_node))
6141 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6145 charwidth = TYPE_PRECISION (char_type_node);
6146 type = TREE_TYPE (constructor_type);
6147 p = TREE_STRING_POINTER (str);
6148 end = p + TREE_STRING_LENGTH (str);
6150 for (purpose = bitsize_zero_node;
6151 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6152 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6154 if (wchar_bytes == 1)
6156 val[1] = (unsigned char) *p++;
6163 for (byte = 0; byte < wchar_bytes; byte++)
6165 if (BYTES_BIG_ENDIAN)
6166 bitpos = (wchar_bytes - byte - 1) * charwidth;
6168 bitpos = byte * charwidth;
6169 val[bitpos < HOST_BITS_PER_WIDE_INT]
6170 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6171 << (bitpos % HOST_BITS_PER_WIDE_INT);
6175 if (!TREE_UNSIGNED (type))
6177 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6178 if (bitpos < HOST_BITS_PER_WIDE_INT)
6180 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6182 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6186 else if (bitpos == HOST_BITS_PER_WIDE_INT)
6191 else if (val[0] & (((HOST_WIDE_INT) 1)
6192 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6193 val[0] |= ((HOST_WIDE_INT) -1)
6194 << (bitpos - HOST_BITS_PER_WIDE_INT);
6197 value = build_int_2 (val[1], val[0]);
6198 TREE_TYPE (value) = type;
6199 add_pending_init (purpose, value);
6202 constructor_incremental = 0;
6205 /* Return value of FIELD in pending initializer or zero if the field was
6206 not initialized yet. */
6209 find_init_member (field)
6212 struct init_node *p;
6214 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6216 if (constructor_incremental
6217 && tree_int_cst_lt (field, constructor_unfilled_index))
6218 set_nonincremental_init ();
6220 p = constructor_pending_elts;
6223 if (tree_int_cst_lt (field, p->purpose))
6225 else if (tree_int_cst_lt (p->purpose, field))
6231 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6233 tree bitpos = bit_position (field);
6235 if (constructor_incremental
6236 && (!constructor_unfilled_fields
6237 || tree_int_cst_lt (bitpos,
6238 bit_position (constructor_unfilled_fields))))
6239 set_nonincremental_init ();
6241 p = constructor_pending_elts;
6244 if (field == p->purpose)
6246 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6252 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6254 if (constructor_elements
6255 && TREE_PURPOSE (constructor_elements) == field)
6256 return TREE_VALUE (constructor_elements);
6261 /* "Output" the next constructor element.
6262 At top level, really output it to assembler code now.
6263 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6264 TYPE is the data type that the containing data type wants here.
6265 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6267 PENDING if non-nil means output pending elements that belong
6268 right after this element. (PENDING is normally 1;
6269 it is 0 while outputting pending elements, to avoid recursion.) */
6272 output_init_element (value, type, field, pending)
6273 tree value, type, field;
6276 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6277 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6278 && !(TREE_CODE (value) == STRING_CST
6279 && TREE_CODE (type) == ARRAY_TYPE
6280 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6281 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6282 TYPE_MAIN_VARIANT (type))))
6283 value = default_conversion (value);
6285 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
6286 && require_constant_value && !flag_isoc99 && pending)
6288 /* As an extension, allow initializing objects with static storage
6289 duration with compound literals (which are then treated just as
6290 the brace enclosed list they contain). */
6291 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
6292 value = DECL_INITIAL (decl);
6295 if (value == error_mark_node)
6296 constructor_erroneous = 1;
6297 else if (!TREE_CONSTANT (value))
6298 constructor_constant = 0;
6299 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6300 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6301 || TREE_CODE (constructor_type) == UNION_TYPE)
6302 && DECL_C_BIT_FIELD (field)
6303 && TREE_CODE (value) != INTEGER_CST))
6304 constructor_simple = 0;
6306 if (require_constant_value && ! TREE_CONSTANT (value))
6308 error_init ("initializer element is not constant");
6309 value = error_mark_node;
6311 else if (require_constant_elements
6312 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6313 pedwarn ("initializer element is not computable at load time");
6315 /* If this field is empty (and not at the end of structure),
6316 don't do anything other than checking the initializer. */
6318 && (TREE_TYPE (field) == error_mark_node
6319 || (COMPLETE_TYPE_P (TREE_TYPE (field))
6320 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6321 && (TREE_CODE (constructor_type) == ARRAY_TYPE
6322 || TREE_CHAIN (field)))))
6325 value = digest_init (type, value, require_constant_value,
6326 require_constant_elements);
6327 if (value == error_mark_node)
6329 constructor_erroneous = 1;
6333 /* If this element doesn't come next in sequence,
6334 put it on constructor_pending_elts. */
6335 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6336 && (!constructor_incremental
6337 || !tree_int_cst_equal (field, constructor_unfilled_index)))
6339 if (constructor_incremental
6340 && tree_int_cst_lt (field, constructor_unfilled_index))
6341 set_nonincremental_init ();
6343 add_pending_init (field, value);
6346 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6347 && (!constructor_incremental
6348 || field != constructor_unfilled_fields))
6350 /* We do this for records but not for unions. In a union,
6351 no matter which field is specified, it can be initialized
6352 right away since it starts at the beginning of the union. */
6353 if (constructor_incremental)
6355 if (!constructor_unfilled_fields)
6356 set_nonincremental_init ();
6359 tree bitpos, unfillpos;
6361 bitpos = bit_position (field);
6362 unfillpos = bit_position (constructor_unfilled_fields);
6364 if (tree_int_cst_lt (bitpos, unfillpos))
6365 set_nonincremental_init ();
6369 add_pending_init (field, value);
6372 else if (TREE_CODE (constructor_type) == UNION_TYPE
6373 && constructor_elements)
6375 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6376 warning_init ("initialized field with side-effects overwritten");
6378 /* We can have just one union field set. */
6379 constructor_elements = 0;
6382 /* Otherwise, output this element either to
6383 constructor_elements or to the assembler file. */
6385 if (field && TREE_CODE (field) == INTEGER_CST)
6386 field = copy_node (field);
6387 constructor_elements
6388 = tree_cons (field, value, constructor_elements);
6390 /* Advance the variable that indicates sequential elements output. */
6391 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6392 constructor_unfilled_index
6393 = size_binop (PLUS_EXPR, constructor_unfilled_index,
6395 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6397 constructor_unfilled_fields
6398 = TREE_CHAIN (constructor_unfilled_fields);
6400 /* Skip any nameless bit fields. */
6401 while (constructor_unfilled_fields != 0
6402 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6403 && DECL_NAME (constructor_unfilled_fields) == 0)
6404 constructor_unfilled_fields =
6405 TREE_CHAIN (constructor_unfilled_fields);
6407 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6408 constructor_unfilled_fields = 0;
6410 /* Now output any pending elements which have become next. */
6412 output_pending_init_elements (0);
6415 /* Output any pending elements which have become next.
6416 As we output elements, constructor_unfilled_{fields,index}
6417 advances, which may cause other elements to become next;
6418 if so, they too are output.
6420 If ALL is 0, we return when there are
6421 no more pending elements to output now.
6423 If ALL is 1, we output space as necessary so that
6424 we can output all the pending elements. */
6427 output_pending_init_elements (all)
6430 struct init_node *elt = constructor_pending_elts;
6435 /* Look thru the whole pending tree.
6436 If we find an element that should be output now,
6437 output it. Otherwise, set NEXT to the element
6438 that comes first among those still pending. */
6443 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6445 if (tree_int_cst_equal (elt->purpose,
6446 constructor_unfilled_index))
6447 output_init_element (elt->value,
6448 TREE_TYPE (constructor_type),
6449 constructor_unfilled_index, 0);
6450 else if (tree_int_cst_lt (constructor_unfilled_index,
6453 /* Advance to the next smaller node. */
6458 /* We have reached the smallest node bigger than the
6459 current unfilled index. Fill the space first. */
6460 next = elt->purpose;
6466 /* Advance to the next bigger node. */
6471 /* We have reached the biggest node in a subtree. Find
6472 the parent of it, which is the next bigger node. */
6473 while (elt->parent && elt->parent->right == elt)
6476 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6479 next = elt->purpose;
6485 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6486 || TREE_CODE (constructor_type) == UNION_TYPE)
6488 tree ctor_unfilled_bitpos, elt_bitpos;
6490 /* If the current record is complete we are done. */
6491 if (constructor_unfilled_fields == 0)
6494 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6495 elt_bitpos = bit_position (elt->purpose);
6496 /* We can't compare fields here because there might be empty
6497 fields in between. */
6498 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6500 constructor_unfilled_fields = elt->purpose;
6501 output_init_element (elt->value, TREE_TYPE (elt->purpose),
6504 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6506 /* Advance to the next smaller node. */
6511 /* We have reached the smallest node bigger than the
6512 current unfilled field. Fill the space first. */
6513 next = elt->purpose;
6519 /* Advance to the next bigger node. */
6524 /* We have reached the biggest node in a subtree. Find
6525 the parent of it, which is the next bigger node. */
6526 while (elt->parent && elt->parent->right == elt)
6530 && (tree_int_cst_lt (ctor_unfilled_bitpos,
6531 bit_position (elt->purpose))))
6533 next = elt->purpose;
6541 /* Ordinarily return, but not if we want to output all
6542 and there are elements left. */
6543 if (! (all && next != 0))
6546 /* If it's not incremental, just skip over the gap, so that after
6547 jumping to retry we will output the next successive element. */
6548 if (TREE_CODE (constructor_type) == RECORD_TYPE
6549 || TREE_CODE (constructor_type) == UNION_TYPE)
6550 constructor_unfilled_fields = next;
6551 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6552 constructor_unfilled_index = next;
6554 /* ELT now points to the node in the pending tree with the next
6555 initializer to output. */
6559 /* Add one non-braced element to the current constructor level.
6560 This adjusts the current position within the constructor's type.
6561 This may also start or terminate implicit levels
6562 to handle a partly-braced initializer.
6564 Once this has found the correct level for the new element,
6565 it calls output_init_element. */
6568 process_init_element (value)
6571 tree orig_value = value;
6572 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6574 designator_depth = 0;
6575 designator_errorneous = 0;
6577 /* Handle superfluous braces around string cst as in
6578 char x[] = {"foo"}; */
6581 && TREE_CODE (constructor_type) == ARRAY_TYPE
6582 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6583 && integer_zerop (constructor_unfilled_index))
6585 if (constructor_stack->replacement_value)
6586 error_init ("excess elements in char array initializer");
6587 constructor_stack->replacement_value = value;
6591 if (constructor_stack->replacement_value != 0)
6593 error_init ("excess elements in struct initializer");
6597 /* Ignore elements of a brace group if it is entirely superfluous
6598 and has already been diagnosed. */
6599 if (constructor_type == 0)
6602 /* If we've exhausted any levels that didn't have braces,
6604 while (constructor_stack->implicit)
6606 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6607 || TREE_CODE (constructor_type) == UNION_TYPE)
6608 && constructor_fields == 0)
6609 process_init_element (pop_init_level (1));
6610 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6611 && (constructor_max_index == 0
6612 || tree_int_cst_lt (constructor_max_index,
6613 constructor_index)))
6614 process_init_element (pop_init_level (1));
6619 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6620 if (constructor_range_stack)
6622 /* If value is a compound literal and we'll be just using its
6623 content, don't put it into a SAVE_EXPR. */
6624 if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
6625 || !require_constant_value
6627 value = save_expr (value);
6632 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6635 enum tree_code fieldcode;
6637 if (constructor_fields == 0)
6639 pedwarn_init ("excess elements in struct initializer");
6643 fieldtype = TREE_TYPE (constructor_fields);
6644 if (fieldtype != error_mark_node)
6645 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6646 fieldcode = TREE_CODE (fieldtype);
6648 /* Accept a string constant to initialize a subarray. */
6650 && fieldcode == ARRAY_TYPE
6651 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6654 /* Otherwise, if we have come to a subaggregate,
6655 and we don't have an element of its type, push into it. */
6656 else if (value != 0 && !constructor_no_implicit
6657 && value != error_mark_node
6658 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6659 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6660 || fieldcode == UNION_TYPE))
6662 push_init_level (1);
6668 push_member_name (constructor_fields);
6669 output_init_element (value, fieldtype, constructor_fields, 1);
6670 RESTORE_SPELLING_DEPTH (constructor_depth);
6673 /* Do the bookkeeping for an element that was
6674 directly output as a constructor. */
6676 /* For a record, keep track of end position of last field. */
6677 if (DECL_SIZE (constructor_fields))
6678 constructor_bit_index
6679 = size_binop (PLUS_EXPR,
6680 bit_position (constructor_fields),
6681 DECL_SIZE (constructor_fields));
6683 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6684 /* Skip any nameless bit fields. */
6685 while (constructor_unfilled_fields != 0
6686 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6687 && DECL_NAME (constructor_unfilled_fields) == 0)
6688 constructor_unfilled_fields =
6689 TREE_CHAIN (constructor_unfilled_fields);
6692 constructor_fields = TREE_CHAIN (constructor_fields);
6693 /* Skip any nameless bit fields at the beginning. */
6694 while (constructor_fields != 0
6695 && DECL_C_BIT_FIELD (constructor_fields)
6696 && DECL_NAME (constructor_fields) == 0)
6697 constructor_fields = TREE_CHAIN (constructor_fields);
6699 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6702 enum tree_code fieldcode;
6704 if (constructor_fields == 0)
6706 pedwarn_init ("excess elements in union initializer");
6710 fieldtype = TREE_TYPE (constructor_fields);
6711 if (fieldtype != error_mark_node)
6712 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6713 fieldcode = TREE_CODE (fieldtype);
6715 /* Warn that traditional C rejects initialization of unions.
6716 We skip the warning if the value is zero. This is done
6717 under the assumption that the zero initializer in user
6718 code appears conditioned on e.g. __STDC__ to avoid
6719 "missing initializer" warnings and relies on default
6720 initialization to zero in the traditional C case.
6721 We also skip the warning if the initializer is designated,
6722 again on the assumption that this must be conditional on
6723 __STDC__ anyway (and we've already complained about the
6724 member-designator already). */
6725 if (warn_traditional && !in_system_header && !constructor_designated
6726 && !(value && (integer_zerop (value) || real_zerop (value))))
6727 warning ("traditional C rejects initialization of unions");
6729 /* Accept a string constant to initialize a subarray. */
6731 && fieldcode == ARRAY_TYPE
6732 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6735 /* Otherwise, if we have come to a subaggregate,
6736 and we don't have an element of its type, push into it. */
6737 else if (value != 0 && !constructor_no_implicit
6738 && value != error_mark_node
6739 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6740 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6741 || fieldcode == UNION_TYPE))
6743 push_init_level (1);
6749 push_member_name (constructor_fields);
6750 output_init_element (value, fieldtype, constructor_fields, 1);
6751 RESTORE_SPELLING_DEPTH (constructor_depth);
6754 /* Do the bookkeeping for an element that was
6755 directly output as a constructor. */
6757 constructor_bit_index = DECL_SIZE (constructor_fields);
6758 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6761 constructor_fields = 0;
6763 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6765 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6766 enum tree_code eltcode = TREE_CODE (elttype);
6768 /* Accept a string constant to initialize a subarray. */
6770 && eltcode == ARRAY_TYPE
6771 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6774 /* Otherwise, if we have come to a subaggregate,
6775 and we don't have an element of its type, push into it. */
6776 else if (value != 0 && !constructor_no_implicit
6777 && value != error_mark_node
6778 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6779 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6780 || eltcode == UNION_TYPE))
6782 push_init_level (1);
6786 if (constructor_max_index != 0
6787 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6788 || integer_all_onesp (constructor_max_index)))
6790 pedwarn_init ("excess elements in array initializer");
6794 /* Now output the actual element. */
6797 push_array_bounds (tree_low_cst (constructor_index, 0));
6798 output_init_element (value, elttype, constructor_index, 1);
6799 RESTORE_SPELLING_DEPTH (constructor_depth);
6803 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6806 /* If we are doing the bookkeeping for an element that was
6807 directly output as a constructor, we must update
6808 constructor_unfilled_index. */
6809 constructor_unfilled_index = constructor_index;
6812 /* Handle the sole element allowed in a braced initializer
6813 for a scalar variable. */
6814 else if (constructor_fields == 0)
6816 pedwarn_init ("excess elements in scalar initializer");
6822 output_init_element (value, constructor_type, NULL_TREE, 1);
6823 constructor_fields = 0;
6826 /* Handle range initializers either at this level or anywhere higher
6827 in the designator stack. */
6828 if (constructor_range_stack)
6830 struct constructor_range_stack *p, *range_stack;
6833 range_stack = constructor_range_stack;
6834 constructor_range_stack = 0;
6835 while (constructor_stack != range_stack->stack)
6837 if (!constructor_stack->implicit)
6839 process_init_element (pop_init_level (1));
6841 for (p = range_stack;
6842 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6845 if (!constructor_stack->implicit)
6847 process_init_element (pop_init_level (1));
6850 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6851 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6856 constructor_index = p->index;
6857 constructor_fields = p->fields;
6858 if (finish && p->range_end && p->index == p->range_start)
6866 push_init_level (2);
6867 p->stack = constructor_stack;
6868 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6869 p->index = p->range_start;
6873 constructor_range_stack = range_stack;
6880 constructor_range_stack = 0;
6883 /* Build a simple asm-statement, from one string literal. */
6885 simple_asm_stmt (expr)
6890 if (TREE_CODE (expr) == ADDR_EXPR)
6891 expr = TREE_OPERAND (expr, 0);
6893 if (TREE_CODE (expr) == STRING_CST)
6897 if (TREE_CHAIN (expr))
6898 expr = combine_strings (expr);
6899 stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6900 NULL_TREE, NULL_TREE,
6902 ASM_INPUT_P (stmt) = 1;
6906 error ("argument of `asm' is not a constant string");
6910 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6911 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6914 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6923 if (TREE_CHAIN (string))
6924 string = combine_strings (string);
6925 if (TREE_CODE (string) != STRING_CST)
6927 error ("asm template is not a string constant");
6931 if (cv_qualifier != NULL_TREE
6932 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6934 warning ("%s qualifier ignored on asm",
6935 IDENTIFIER_POINTER (cv_qualifier));
6936 cv_qualifier = NULL_TREE;
6939 /* We can remove output conversions that change the type,
6940 but not the mode. */
6941 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6943 tree output = TREE_VALUE (tail);
6945 STRIP_NOPS (output);
6946 TREE_VALUE (tail) = output;
6948 /* Allow conversions as LHS here. build_modify_expr as called below
6949 will do the right thing with them. */
6950 while (TREE_CODE (output) == NOP_EXPR
6951 || TREE_CODE (output) == CONVERT_EXPR
6952 || TREE_CODE (output) == FLOAT_EXPR
6953 || TREE_CODE (output) == FIX_TRUNC_EXPR
6954 || TREE_CODE (output) == FIX_FLOOR_EXPR
6955 || TREE_CODE (output) == FIX_ROUND_EXPR
6956 || TREE_CODE (output) == FIX_CEIL_EXPR)
6957 output = TREE_OPERAND (output, 0);
6959 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6962 /* Remove output conversions that change the type but not the mode. */
6963 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6965 tree output = TREE_VALUE (tail);
6966 STRIP_NOPS (output);
6967 TREE_VALUE (tail) = output;
6970 /* Perform default conversions on array and function inputs.
6971 Don't do this for other types as it would screw up operands
6972 expected to be in memory. */
6973 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6974 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6976 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6977 outputs, inputs, clobbers));
6980 /* Expand an ASM statement with operands, handling output operands
6981 that are not variables or INDIRECT_REFS by transforming such
6982 cases into cases that expand_asm_operands can handle.
6984 Arguments are same as for expand_asm_operands. */
6987 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6988 tree string, outputs, inputs, clobbers;
6990 const char *filename;
6993 int noutputs = list_length (outputs);
6995 /* o[I] is the place that output number I should be written. */
6996 tree *o = (tree *) alloca (noutputs * sizeof (tree));
6999 /* Record the contents of OUTPUTS before it is modified. */
7000 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
7001 o[i] = TREE_VALUE (tail);
7003 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
7004 OUTPUTS some trees for where the values were actually stored. */
7005 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
7007 /* Copy all the intermediate outputs into the specified outputs. */
7008 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
7010 if (o[i] != TREE_VALUE (tail))
7012 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
7013 NULL_RTX, VOIDmode, EXPAND_NORMAL);
7016 /* Restore the original value so that it's correct the next
7017 time we expand this function. */
7018 TREE_VALUE (tail) = o[i];
7020 /* Detect modification of read-only values.
7021 (Otherwise done by build_modify_expr.) */
7024 tree type = TREE_TYPE (o[i]);
7025 if (TREE_READONLY (o[i])
7026 || TYPE_READONLY (type)
7027 || ((TREE_CODE (type) == RECORD_TYPE
7028 || TREE_CODE (type) == UNION_TYPE)
7029 && C_TYPE_FIELDS_READONLY (type)))
7030 readonly_warning (o[i], "modification by `asm'");
7034 /* Those MODIFY_EXPRs could do autoincrements. */
7038 /* Expand a C `return' statement.
7039 RETVAL is the expression for what to return,
7040 or a null pointer for `return;' with no value. */
7043 c_expand_return (retval)
7046 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
7048 if (TREE_THIS_VOLATILE (current_function_decl))
7049 warning ("function declared `noreturn' has a `return' statement");
7053 current_function_returns_null = 1;
7054 if ((warn_return_type || flag_isoc99)
7055 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7056 pedwarn_c99 ("`return' with no value, in function returning non-void");
7058 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7060 current_function_returns_null = 1;
7061 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7062 pedwarn ("`return' with a value, in function returning void");
7066 tree t = convert_for_assignment (valtype, retval, _("return"),
7067 NULL_TREE, NULL_TREE, 0);
7068 tree res = DECL_RESULT (current_function_decl);
7071 if (t == error_mark_node)
7074 inner = t = convert (TREE_TYPE (res), t);
7076 /* Strip any conversions, additions, and subtractions, and see if
7077 we are returning the address of a local variable. Warn if so. */
7080 switch (TREE_CODE (inner))
7082 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
7084 inner = TREE_OPERAND (inner, 0);
7088 /* If the second operand of the MINUS_EXPR has a pointer
7089 type (or is converted from it), this may be valid, so
7090 don't give a warning. */
7092 tree op1 = TREE_OPERAND (inner, 1);
7094 while (! POINTER_TYPE_P (TREE_TYPE (op1))
7095 && (TREE_CODE (op1) == NOP_EXPR
7096 || TREE_CODE (op1) == NON_LVALUE_EXPR
7097 || TREE_CODE (op1) == CONVERT_EXPR))
7098 op1 = TREE_OPERAND (op1, 0);
7100 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7103 inner = TREE_OPERAND (inner, 0);
7108 inner = TREE_OPERAND (inner, 0);
7110 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7111 inner = TREE_OPERAND (inner, 0);
7113 if (TREE_CODE (inner) == VAR_DECL
7114 && ! DECL_EXTERNAL (inner)
7115 && ! TREE_STATIC (inner)
7116 && DECL_CONTEXT (inner) == current_function_decl)
7117 warning ("function returns address of local variable");
7127 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7128 current_function_returns_value = 1;
7131 return add_stmt (build_return_stmt (retval));
7135 /* The SWITCH_STMT being built. */
7137 /* A splay-tree mapping the low element of a case range to the high
7138 element, or NULL_TREE if there is no high element. Used to
7139 determine whether or not a new case label duplicates an old case
7140 label. We need a tree, rather than simply a hash table, because
7141 of the GNU case range extension. */
7143 /* The next node on the stack. */
7144 struct c_switch *next;
7147 /* A stack of the currently active switch statements. The innermost
7148 switch statement is on the top of the stack. There is no need to
7149 mark the stack for garbage collection because it is only active
7150 during the processing of the body of a function, and we never
7151 collect at that point. */
7153 static struct c_switch *switch_stack;
7155 /* Start a C switch statement, testing expression EXP. Return the new
7162 enum tree_code code;
7164 struct c_switch *cs;
7166 if (exp != error_mark_node)
7168 code = TREE_CODE (TREE_TYPE (exp));
7169 type = TREE_TYPE (exp);
7171 if (! INTEGRAL_TYPE_P (type)
7172 && code != ERROR_MARK)
7174 error ("switch quantity not an integer");
7175 exp = integer_zero_node;
7179 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7181 if (warn_traditional && !in_system_header
7182 && (type == long_integer_type_node
7183 || type == long_unsigned_type_node))
7184 warning ("`long' switch expression not converted to `int' in ISO C");
7186 exp = default_conversion (exp);
7187 type = TREE_TYPE (exp);
7191 /* Add this new SWITCH_STMT to the stack. */
7192 cs = (struct c_switch *) xmalloc (sizeof (*cs));
7193 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7194 cs->cases = splay_tree_new (case_compare, NULL, NULL);
7195 cs->next = switch_stack;
7198 return add_stmt (switch_stack->switch_stmt);
7201 /* Process a case label. */
7204 do_case (low_value, high_value)
7208 tree label = NULL_TREE;
7212 label = c_add_case_label (switch_stack->cases,
7213 SWITCH_COND (switch_stack->switch_stmt),
7214 low_value, high_value);
7215 if (label == error_mark_node)
7219 error ("case label not within a switch statement");
7221 error ("`default' label not within a switch statement");
7226 /* Finish the switch statement. */
7231 struct c_switch *cs = switch_stack;
7233 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7235 /* Pop the stack. */
7236 switch_stack = switch_stack->next;
7237 splay_tree_delete (cs->cases);