1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 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. */
30 #include "coretypes.h"
34 #include "langhooks.h"
44 #include "tree-iterator.h"
45 #include "tree-gimple.h"
47 /* Possible cases of implicit bad conversions. Used to select
48 diagnostic messages in convert_for_assignment. */
57 /* The level of nesting inside "__alignof__". */
60 /* The level of nesting inside "sizeof". */
63 /* The level of nesting inside "typeof". */
66 /* Nonzero if we've already printed a "missing braces around initializer"
67 message within this initializer. */
68 static int missing_braces_mentioned
;
70 static int require_constant_value
;
71 static int require_constant_elements
;
73 static tree
qualify_type (tree
, tree
);
74 static int tagged_types_tu_compatible_p (tree
, tree
);
75 static int comp_target_types (tree
, tree
, int);
76 static int function_types_compatible_p (tree
, tree
);
77 static int type_lists_compatible_p (tree
, tree
);
78 static tree
decl_constant_value_for_broken_optimization (tree
);
79 static tree
default_function_array_conversion (tree
);
80 static tree
lookup_field (tree
, tree
);
81 static tree
convert_arguments (tree
, tree
, tree
, tree
);
82 static tree
pointer_diff (tree
, tree
);
83 static tree
convert_for_assignment (tree
, tree
, enum impl_conv
, tree
, tree
,
85 static tree
valid_compound_expr_initializer (tree
, tree
);
86 static void push_string (const char *);
87 static void push_member_name (tree
);
88 static void push_array_bounds (int);
89 static int spelling_length (void);
90 static char *print_spelling (char *);
91 static void warning_init (const char *);
92 static tree
digest_init (tree
, tree
, bool, int);
93 static void output_init_element (tree
, bool, tree
, tree
, int);
94 static void output_pending_init_elements (int);
95 static int set_designator (int);
96 static void push_range_stack (tree
);
97 static void add_pending_init (tree
, tree
);
98 static void set_nonincremental_init (void);
99 static void set_nonincremental_init_from_string (tree
);
100 static tree
find_init_member (tree
);
101 static void readonly_error (tree
, enum lvalue_use
);
102 static void record_maybe_used_decl (tree
);
104 /* Do `exp = require_complete_type (exp);' to make sure exp
105 does not have an incomplete type. (That includes void types.) */
108 require_complete_type (tree value
)
110 tree type
= TREE_TYPE (value
);
112 if (value
== error_mark_node
|| type
== error_mark_node
)
113 return error_mark_node
;
115 /* First, detect a valid value with a complete type. */
116 if (COMPLETE_TYPE_P (type
))
119 c_incomplete_type_error (value
, type
);
120 return error_mark_node
;
123 /* Print an error message for invalid use of an incomplete type.
124 VALUE is the expression that was used (or 0 if that isn't known)
125 and TYPE is the type that was invalid. */
128 c_incomplete_type_error (tree value
, tree type
)
130 const char *type_code_string
;
132 /* Avoid duplicate error message. */
133 if (TREE_CODE (type
) == ERROR_MARK
)
136 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
137 || TREE_CODE (value
) == PARM_DECL
))
138 error ("%qs has an incomplete type",
139 IDENTIFIER_POINTER (DECL_NAME (value
)));
143 /* We must print an error message. Be clever about what it says. */
145 switch (TREE_CODE (type
))
148 type_code_string
= "struct";
152 type_code_string
= "union";
156 type_code_string
= "enum";
160 error ("invalid use of void expression");
164 if (TYPE_DOMAIN (type
))
166 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL
)
168 error ("invalid use of flexible array member");
171 type
= TREE_TYPE (type
);
174 error ("invalid use of array with unspecified bounds");
181 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
182 error ("invalid use of undefined type %<%s %s%>",
183 type_code_string
, IDENTIFIER_POINTER (TYPE_NAME (type
)));
185 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
186 error ("invalid use of incomplete typedef %qs",
187 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
))));
191 /* Given a type, apply default promotions wrt unnamed function
192 arguments and return the new type. */
195 c_type_promotes_to (tree type
)
197 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
198 return double_type_node
;
200 if (c_promoting_integer_type_p (type
))
202 /* Preserve unsignedness if not really getting any wider. */
203 if (TYPE_UNSIGNED (type
)
204 && (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
205 return unsigned_type_node
;
206 return integer_type_node
;
212 /* Return a variant of TYPE which has all the type qualifiers of LIKE
213 as well as those of TYPE. */
216 qualify_type (tree type
, tree like
)
218 return c_build_qualified_type (type
,
219 TYPE_QUALS (type
) | TYPE_QUALS (like
));
222 /* Return the composite type of two compatible types.
224 We assume that comptypes has already been done and returned
225 nonzero; if that isn't so, this may crash. In particular, we
226 assume that qualifiers match. */
229 composite_type (tree t1
, tree t2
)
231 enum tree_code code1
;
232 enum tree_code code2
;
235 /* Save time if the two types are the same. */
237 if (t1
== t2
) return t1
;
239 /* If one type is nonsense, use the other. */
240 if (t1
== error_mark_node
)
242 if (t2
== error_mark_node
)
245 code1
= TREE_CODE (t1
);
246 code2
= TREE_CODE (t2
);
248 /* Merge the attributes. */
249 attributes
= targetm
.merge_type_attributes (t1
, t2
);
251 /* If one is an enumerated type and the other is the compatible
252 integer type, the composite type might be either of the two
253 (DR#013 question 3). For consistency, use the enumerated type as
254 the composite type. */
256 if (code1
== ENUMERAL_TYPE
&& code2
== INTEGER_TYPE
)
258 if (code2
== ENUMERAL_TYPE
&& code1
== INTEGER_TYPE
)
261 gcc_assert (code1
== code2
);
266 /* For two pointers, do this recursively on the target type. */
268 tree pointed_to_1
= TREE_TYPE (t1
);
269 tree pointed_to_2
= TREE_TYPE (t2
);
270 tree target
= composite_type (pointed_to_1
, pointed_to_2
);
271 t1
= build_pointer_type (target
);
272 t1
= build_type_attribute_variant (t1
, attributes
);
273 return qualify_type (t1
, t2
);
278 tree elt
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
280 /* We should not have any type quals on arrays at all. */
281 gcc_assert (!TYPE_QUALS (t1
) && !TYPE_QUALS (t2
));
283 /* Save space: see if the result is identical to one of the args. */
284 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
285 return build_type_attribute_variant (t1
, attributes
);
286 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
287 return build_type_attribute_variant (t2
, attributes
);
289 if (elt
== TREE_TYPE (t1
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
290 return build_type_attribute_variant (t1
, attributes
);
291 if (elt
== TREE_TYPE (t2
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
292 return build_type_attribute_variant (t2
, attributes
);
294 /* Merge the element types, and have a size if either arg has one. */
295 t1
= build_array_type (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
296 return build_type_attribute_variant (t1
, attributes
);
300 /* Function types: prefer the one that specified arg types.
301 If both do, merge the arg types. Also merge the return types. */
303 tree valtype
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
304 tree p1
= TYPE_ARG_TYPES (t1
);
305 tree p2
= TYPE_ARG_TYPES (t2
);
310 /* Save space: see if the result is identical to one of the args. */
311 if (valtype
== TREE_TYPE (t1
) && !TYPE_ARG_TYPES (t2
))
312 return build_type_attribute_variant (t1
, attributes
);
313 if (valtype
== TREE_TYPE (t2
) && !TYPE_ARG_TYPES (t1
))
314 return build_type_attribute_variant (t2
, attributes
);
316 /* Simple way if one arg fails to specify argument types. */
317 if (TYPE_ARG_TYPES (t1
) == 0)
319 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t2
));
320 t1
= build_type_attribute_variant (t1
, attributes
);
321 return qualify_type (t1
, t2
);
323 if (TYPE_ARG_TYPES (t2
) == 0)
325 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t1
));
326 t1
= build_type_attribute_variant (t1
, attributes
);
327 return qualify_type (t1
, t2
);
330 /* If both args specify argument types, we must merge the two
331 lists, argument by argument. */
332 /* Tell global_bindings_p to return false so that variable_size
333 doesn't abort on VLAs in parameter types. */
334 c_override_global_bindings_to_false
= true;
336 len
= list_length (p1
);
339 for (i
= 0; i
< len
; i
++)
340 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
345 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
))
347 /* A null type means arg type is not specified.
348 Take whatever the other function type has. */
349 if (TREE_VALUE (p1
) == 0)
351 TREE_VALUE (n
) = TREE_VALUE (p2
);
354 if (TREE_VALUE (p2
) == 0)
356 TREE_VALUE (n
) = TREE_VALUE (p1
);
360 /* Given wait (union {union wait *u; int *i} *)
361 and wait (union wait *),
362 prefer union wait * as type of parm. */
363 if (TREE_CODE (TREE_VALUE (p1
)) == UNION_TYPE
364 && TREE_VALUE (p1
) != TREE_VALUE (p2
))
367 for (memb
= TYPE_FIELDS (TREE_VALUE (p1
));
368 memb
; memb
= TREE_CHAIN (memb
))
369 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (p2
)))
371 TREE_VALUE (n
) = TREE_VALUE (p2
);
373 pedwarn ("function types not truly compatible in ISO C");
377 if (TREE_CODE (TREE_VALUE (p2
)) == UNION_TYPE
378 && TREE_VALUE (p2
) != TREE_VALUE (p1
))
381 for (memb
= TYPE_FIELDS (TREE_VALUE (p2
));
382 memb
; memb
= TREE_CHAIN (memb
))
383 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (p1
)))
385 TREE_VALUE (n
) = TREE_VALUE (p1
);
387 pedwarn ("function types not truly compatible in ISO C");
391 TREE_VALUE (n
) = composite_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
395 c_override_global_bindings_to_false
= false;
396 t1
= build_function_type (valtype
, newargs
);
397 t1
= qualify_type (t1
, t2
);
398 /* ... falls through ... */
402 return build_type_attribute_variant (t1
, attributes
);
407 /* Return the type of a conditional expression between pointers to
408 possibly differently qualified versions of compatible types.
410 We assume that comp_target_types has already been done and returned
411 nonzero; if that isn't so, this may crash. */
414 common_pointer_type (tree t1
, tree t2
)
421 /* Save time if the two types are the same. */
423 if (t1
== t2
) return t1
;
425 /* If one type is nonsense, use the other. */
426 if (t1
== error_mark_node
)
428 if (t2
== error_mark_node
)
431 gcc_assert (TREE_CODE (t1
) == POINTER_TYPE
432 && TREE_CODE (t2
) == POINTER_TYPE
);
434 /* Merge the attributes. */
435 attributes
= targetm
.merge_type_attributes (t1
, t2
);
437 /* Find the composite type of the target types, and combine the
438 qualifiers of the two types' targets. */
439 pointed_to_1
= TREE_TYPE (t1
);
440 pointed_to_2
= TREE_TYPE (t2
);
441 target
= composite_type (TYPE_MAIN_VARIANT (pointed_to_1
),
442 TYPE_MAIN_VARIANT (pointed_to_2
));
443 t1
= build_pointer_type (c_build_qualified_type
445 TYPE_QUALS (pointed_to_1
) |
446 TYPE_QUALS (pointed_to_2
)));
447 return build_type_attribute_variant (t1
, attributes
);
450 /* Return the common type for two arithmetic types under the usual
451 arithmetic conversions. The default conversions have already been
452 applied, and enumerated types converted to their compatible integer
453 types. The resulting type is unqualified and has no attributes.
455 This is the type for the result of most arithmetic operations
456 if the operands have the given two types. */
459 common_type (tree t1
, tree t2
)
461 enum tree_code code1
;
462 enum tree_code code2
;
464 /* If one type is nonsense, use the other. */
465 if (t1
== error_mark_node
)
467 if (t2
== error_mark_node
)
470 if (TYPE_QUALS (t1
) != TYPE_UNQUALIFIED
)
471 t1
= TYPE_MAIN_VARIANT (t1
);
473 if (TYPE_QUALS (t2
) != TYPE_UNQUALIFIED
)
474 t2
= TYPE_MAIN_VARIANT (t2
);
476 if (TYPE_ATTRIBUTES (t1
) != NULL_TREE
)
477 t1
= build_type_attribute_variant (t1
, NULL_TREE
);
479 if (TYPE_ATTRIBUTES (t2
) != NULL_TREE
)
480 t2
= build_type_attribute_variant (t2
, NULL_TREE
);
482 /* Save time if the two types are the same. */
484 if (t1
== t2
) return t1
;
486 code1
= TREE_CODE (t1
);
487 code2
= TREE_CODE (t2
);
489 gcc_assert (code1
== VECTOR_TYPE
|| code1
== COMPLEX_TYPE
490 || code1
== REAL_TYPE
|| code1
== INTEGER_TYPE
);
491 gcc_assert (code2
== VECTOR_TYPE
|| code2
== COMPLEX_TYPE
492 || code2
== REAL_TYPE
|| code2
== INTEGER_TYPE
);
494 /* If one type is a vector type, return that type. (How the usual
495 arithmetic conversions apply to the vector types extension is not
496 precisely specified.) */
497 if (code1
== VECTOR_TYPE
)
500 if (code2
== VECTOR_TYPE
)
503 /* If one type is complex, form the common type of the non-complex
504 components, then make that complex. Use T1 or T2 if it is the
506 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
508 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
509 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
510 tree subtype
= common_type (subtype1
, subtype2
);
512 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
514 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
517 return build_complex_type (subtype
);
520 /* If only one is real, use it as the result. */
522 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
525 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
528 /* Both real or both integers; use the one with greater precision. */
530 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
532 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
535 /* Same precision. Prefer long longs to longs to ints when the
536 same precision, following the C99 rules on integer type rank
537 (which are equivalent to the C90 rules for C90 types). */
539 if (TYPE_MAIN_VARIANT (t1
) == long_long_unsigned_type_node
540 || TYPE_MAIN_VARIANT (t2
) == long_long_unsigned_type_node
)
541 return long_long_unsigned_type_node
;
543 if (TYPE_MAIN_VARIANT (t1
) == long_long_integer_type_node
544 || TYPE_MAIN_VARIANT (t2
) == long_long_integer_type_node
)
546 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
547 return long_long_unsigned_type_node
;
549 return long_long_integer_type_node
;
552 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
553 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
554 return long_unsigned_type_node
;
556 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
557 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
559 /* But preserve unsignedness from the other type,
560 since long cannot hold all the values of an unsigned int. */
561 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
562 return long_unsigned_type_node
;
564 return long_integer_type_node
;
567 /* Likewise, prefer long double to double even if same size. */
568 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
569 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
570 return long_double_type_node
;
572 /* Otherwise prefer the unsigned one. */
574 if (TYPE_UNSIGNED (t1
))
580 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
581 or various other operations. Return 2 if they are compatible
582 but a warning may be needed if you use them together. */
585 comptypes (tree type1
, tree type2
)
591 /* Suppress errors caused by previously reported errors. */
593 if (t1
== t2
|| !t1
|| !t2
594 || TREE_CODE (t1
) == ERROR_MARK
|| TREE_CODE (t2
) == ERROR_MARK
)
597 /* If either type is the internal version of sizetype, return the
599 if (TREE_CODE (t1
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t1
)
600 && TYPE_ORIG_SIZE_TYPE (t1
))
601 t1
= TYPE_ORIG_SIZE_TYPE (t1
);
603 if (TREE_CODE (t2
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t2
)
604 && TYPE_ORIG_SIZE_TYPE (t2
))
605 t2
= TYPE_ORIG_SIZE_TYPE (t2
);
608 /* Enumerated types are compatible with integer types, but this is
609 not transitive: two enumerated types in the same translation unit
610 are compatible with each other only if they are the same type. */
612 if (TREE_CODE (t1
) == ENUMERAL_TYPE
&& TREE_CODE (t2
) != ENUMERAL_TYPE
)
613 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), TYPE_UNSIGNED (t1
));
614 else if (TREE_CODE (t2
) == ENUMERAL_TYPE
&& TREE_CODE (t1
) != ENUMERAL_TYPE
)
615 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), TYPE_UNSIGNED (t2
));
620 /* Different classes of types can't be compatible. */
622 if (TREE_CODE (t1
) != TREE_CODE (t2
))
625 /* Qualifiers must match. C99 6.7.3p9 */
627 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
630 /* Allow for two different type nodes which have essentially the same
631 definition. Note that we already checked for equality of the type
632 qualifiers (just above). */
634 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
637 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
638 if (!(attrval
= targetm
.comp_type_attributes (t1
, t2
)))
641 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
644 switch (TREE_CODE (t1
))
647 /* We must give ObjC the first crack at comparing pointers, since
648 protocol qualifiers may be involved. */
649 if (c_dialect_objc () && (val
= objc_comptypes (t1
, t2
, 0)) >= 0)
651 /* Do not remove mode or aliasing information. */
652 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
653 || TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
))
655 val
= (TREE_TYPE (t1
) == TREE_TYPE (t2
)
656 ? 1 : comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
)));
660 val
= function_types_compatible_p (t1
, t2
);
665 tree d1
= TYPE_DOMAIN (t1
);
666 tree d2
= TYPE_DOMAIN (t2
);
667 bool d1_variable
, d2_variable
;
668 bool d1_zero
, d2_zero
;
671 /* Target types must match incl. qualifiers. */
672 if (TREE_TYPE (t1
) != TREE_TYPE (t2
)
673 && 0 == (val
= comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
))))
676 /* Sizes must match unless one is missing or variable. */
677 if (d1
== 0 || d2
== 0 || d1
== d2
)
680 d1_zero
= !TYPE_MAX_VALUE (d1
);
681 d2_zero
= !TYPE_MAX_VALUE (d2
);
683 d1_variable
= (!d1_zero
684 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
685 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
686 d2_variable
= (!d2_zero
687 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
688 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
690 if (d1_variable
|| d2_variable
)
692 if (d1_zero
&& d2_zero
)
694 if (d1_zero
|| d2_zero
695 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
))
696 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1
), TYPE_MAX_VALUE (d2
)))
703 /* We are dealing with two distinct structs. In assorted Objective-C
704 corner cases, however, these can still be deemed equivalent. */
705 if (c_dialect_objc () && objc_comptypes (t1
, t2
, 0) == 1)
710 if (val
!= 1 && !same_translation_unit_p (t1
, t2
))
711 val
= tagged_types_tu_compatible_p (t1
, t2
);
715 val
= TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
716 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
));
722 return attrval
== 2 && val
== 1 ? 2 : val
;
725 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
726 ignoring their qualifiers. REFLEXIVE is only used by ObjC - set it
727 to 1 or 0 depending if the check of the pointer types is meant to
728 be reflexive or not (typically, assignments are not reflexive,
729 while comparisons are reflexive).
733 comp_target_types (tree ttl
, tree ttr
, int reflexive
)
737 /* Give objc_comptypes a crack at letting these types through. */
738 if ((val
= objc_comptypes (ttl
, ttr
, reflexive
)) >= 0)
741 val
= comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl
)),
742 TYPE_MAIN_VARIANT (TREE_TYPE (ttr
)));
744 if (val
== 2 && pedantic
)
745 pedwarn ("types are not quite compatible");
749 /* Subroutines of `comptypes'. */
751 /* Determine whether two trees derive from the same translation unit.
752 If the CONTEXT chain ends in a null, that tree's context is still
753 being parsed, so if two trees have context chains ending in null,
754 they're in the same translation unit. */
756 same_translation_unit_p (tree t1
, tree t2
)
758 while (t1
&& TREE_CODE (t1
) != TRANSLATION_UNIT_DECL
)
759 switch (TREE_CODE_CLASS (TREE_CODE (t1
)))
761 case tcc_declaration
:
762 t1
= DECL_CONTEXT (t1
); break;
764 t1
= TYPE_CONTEXT (t1
); break;
765 case tcc_exceptional
:
766 t1
= BLOCK_SUPERCONTEXT (t1
); break; /* assume block */
767 default: gcc_unreachable ();
770 while (t2
&& TREE_CODE (t2
) != TRANSLATION_UNIT_DECL
)
771 switch (TREE_CODE_CLASS (TREE_CODE (t2
)))
773 case tcc_declaration
:
774 t2
= DECL_CONTEXT (t2
); break;
776 t2
= TYPE_CONTEXT (t2
); break;
777 case tcc_exceptional
:
778 t2
= BLOCK_SUPERCONTEXT (t2
); break; /* assume block */
779 default: gcc_unreachable ();
785 /* The C standard says that two structures in different translation
786 units are compatible with each other only if the types of their
787 fields are compatible (among other things). So, consider two copies
788 of this structure: */
790 struct tagged_tu_seen
{
791 const struct tagged_tu_seen
* next
;
796 /* Can they be compatible with each other? We choose to break the
797 recursion by allowing those types to be compatible. */
799 static const struct tagged_tu_seen
* tagged_tu_seen_base
;
801 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
802 compatible. If the two types are not the same (which has been
803 checked earlier), this can only happen when multiple translation
804 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
808 tagged_types_tu_compatible_p (tree t1
, tree t2
)
811 bool needs_warning
= false;
813 /* We have to verify that the tags of the types are the same. This
814 is harder than it looks because this may be a typedef, so we have
815 to go look at the original type. It may even be a typedef of a
817 In the case of compiler-created builtin structs the TYPE_DECL
818 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
819 while (TYPE_NAME (t1
)
820 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
821 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1
)))
822 t1
= DECL_ORIGINAL_TYPE (TYPE_NAME (t1
));
824 while (TYPE_NAME (t2
)
825 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
826 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2
)))
827 t2
= DECL_ORIGINAL_TYPE (TYPE_NAME (t2
));
829 /* C90 didn't have the requirement that the two tags be the same. */
830 if (flag_isoc99
&& TYPE_NAME (t1
) != TYPE_NAME (t2
))
833 /* C90 didn't say what happened if one or both of the types were
834 incomplete; we choose to follow C99 rules here, which is that they
836 if (TYPE_SIZE (t1
) == NULL
837 || TYPE_SIZE (t2
) == NULL
)
841 const struct tagged_tu_seen
* tts_i
;
842 for (tts_i
= tagged_tu_seen_base
; tts_i
!= NULL
; tts_i
= tts_i
->next
)
843 if (tts_i
->t1
== t1
&& tts_i
->t2
== t2
)
847 switch (TREE_CODE (t1
))
852 /* Speed up the case where the type values are in the same order. */
853 tree tv1
= TYPE_VALUES (t1
);
854 tree tv2
= TYPE_VALUES (t2
);
859 for (;tv1
&& tv2
; tv1
= TREE_CHAIN (tv1
), tv2
= TREE_CHAIN (tv2
))
861 if (TREE_PURPOSE (tv1
) != TREE_PURPOSE (tv2
))
863 if (simple_cst_equal (TREE_VALUE (tv1
), TREE_VALUE (tv2
)) != 1)
867 if (tv1
== NULL_TREE
&& tv2
== NULL_TREE
)
869 if (tv1
== NULL_TREE
|| tv2
== NULL_TREE
)
872 if (list_length (TYPE_VALUES (t1
)) != list_length (TYPE_VALUES (t2
)))
875 for (s1
= TYPE_VALUES (t1
); s1
; s1
= TREE_CHAIN (s1
))
877 s2
= purpose_member (TREE_PURPOSE (s1
), TYPE_VALUES (t2
));
879 || simple_cst_equal (TREE_VALUE (s1
), TREE_VALUE (s2
)) != 1)
887 if (list_length (TYPE_FIELDS (t1
)) != list_length (TYPE_FIELDS (t2
)))
890 for (s1
= TYPE_FIELDS (t1
); s1
; s1
= TREE_CHAIN (s1
))
893 struct tagged_tu_seen tts
;
895 tts
.next
= tagged_tu_seen_base
;
898 tagged_tu_seen_base
= &tts
;
900 if (DECL_NAME (s1
) != NULL
)
901 for (s2
= TYPE_FIELDS (t2
); s2
; s2
= TREE_CHAIN (s2
))
902 if (DECL_NAME (s1
) == DECL_NAME (s2
))
905 result
= comptypes (TREE_TYPE (s1
), TREE_TYPE (s2
));
909 needs_warning
= true;
911 if (TREE_CODE (s1
) == FIELD_DECL
912 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
913 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
919 tagged_tu_seen_base
= tts
.next
;
923 return needs_warning
? 2 : 1;
928 struct tagged_tu_seen tts
;
930 tts
.next
= tagged_tu_seen_base
;
933 tagged_tu_seen_base
= &tts
;
935 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
);
937 s1
= TREE_CHAIN (s1
), s2
= TREE_CHAIN (s2
))
940 if (TREE_CODE (s1
) != TREE_CODE (s2
)
941 || DECL_NAME (s1
) != DECL_NAME (s2
))
943 result
= comptypes (TREE_TYPE (s1
), TREE_TYPE (s2
));
947 needs_warning
= true;
949 if (TREE_CODE (s1
) == FIELD_DECL
950 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
951 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
954 tagged_tu_seen_base
= tts
.next
;
957 return needs_warning
? 2 : 1;
965 /* Return 1 if two function types F1 and F2 are compatible.
966 If either type specifies no argument types,
967 the other must specify a fixed number of self-promoting arg types.
968 Otherwise, if one type specifies only the number of arguments,
969 the other must specify that number of self-promoting arg types.
970 Otherwise, the argument types must match. */
973 function_types_compatible_p (tree f1
, tree f2
)
976 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
981 ret1
= TREE_TYPE (f1
);
982 ret2
= TREE_TYPE (f2
);
984 /* 'volatile' qualifiers on a function's return type used to mean
985 the function is noreturn. */
986 if (TYPE_VOLATILE (ret1
) != TYPE_VOLATILE (ret2
))
987 pedwarn ("function return types not compatible due to %<volatile%>");
988 if (TYPE_VOLATILE (ret1
))
989 ret1
= build_qualified_type (TYPE_MAIN_VARIANT (ret1
),
990 TYPE_QUALS (ret1
) & ~TYPE_QUAL_VOLATILE
);
991 if (TYPE_VOLATILE (ret2
))
992 ret2
= build_qualified_type (TYPE_MAIN_VARIANT (ret2
),
993 TYPE_QUALS (ret2
) & ~TYPE_QUAL_VOLATILE
);
994 val
= comptypes (ret1
, ret2
);
998 args1
= TYPE_ARG_TYPES (f1
);
999 args2
= TYPE_ARG_TYPES (f2
);
1001 /* An unspecified parmlist matches any specified parmlist
1002 whose argument types don't need default promotions. */
1006 if (!self_promoting_args_p (args2
))
1008 /* If one of these types comes from a non-prototype fn definition,
1009 compare that with the other type's arglist.
1010 If they don't match, ask for a warning (but no error). */
1011 if (TYPE_ACTUAL_ARG_TYPES (f1
)
1012 && 1 != type_lists_compatible_p (args2
, TYPE_ACTUAL_ARG_TYPES (f1
)))
1018 if (!self_promoting_args_p (args1
))
1020 if (TYPE_ACTUAL_ARG_TYPES (f2
)
1021 && 1 != type_lists_compatible_p (args1
, TYPE_ACTUAL_ARG_TYPES (f2
)))
1026 /* Both types have argument lists: compare them and propagate results. */
1027 val1
= type_lists_compatible_p (args1
, args2
);
1028 return val1
!= 1 ? val1
: val
;
1031 /* Check two lists of types for compatibility,
1032 returning 0 for incompatible, 1 for compatible,
1033 or 2 for compatible with warning. */
1036 type_lists_compatible_p (tree args1
, tree args2
)
1038 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1044 if (args1
== 0 && args2
== 0)
1046 /* If one list is shorter than the other,
1047 they fail to match. */
1048 if (args1
== 0 || args2
== 0)
1050 /* A null pointer instead of a type
1051 means there is supposed to be an argument
1052 but nothing is specified about what type it has.
1053 So match anything that self-promotes. */
1054 if (TREE_VALUE (args1
) == 0)
1056 if (c_type_promotes_to (TREE_VALUE (args2
)) != TREE_VALUE (args2
))
1059 else if (TREE_VALUE (args2
) == 0)
1061 if (c_type_promotes_to (TREE_VALUE (args1
)) != TREE_VALUE (args1
))
1064 /* If one of the lists has an error marker, ignore this arg. */
1065 else if (TREE_CODE (TREE_VALUE (args1
)) == ERROR_MARK
1066 || TREE_CODE (TREE_VALUE (args2
)) == ERROR_MARK
)
1068 else if (!(newval
= comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1
)),
1069 TYPE_MAIN_VARIANT (TREE_VALUE (args2
)))))
1071 /* Allow wait (union {union wait *u; int *i} *)
1072 and wait (union wait *) to be compatible. */
1073 if (TREE_CODE (TREE_VALUE (args1
)) == UNION_TYPE
1074 && (TYPE_NAME (TREE_VALUE (args1
)) == 0
1075 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1
)))
1076 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1
))) == INTEGER_CST
1077 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1
)),
1078 TYPE_SIZE (TREE_VALUE (args2
))))
1081 for (memb
= TYPE_FIELDS (TREE_VALUE (args1
));
1082 memb
; memb
= TREE_CHAIN (memb
))
1083 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (args2
)))
1088 else if (TREE_CODE (TREE_VALUE (args2
)) == UNION_TYPE
1089 && (TYPE_NAME (TREE_VALUE (args2
)) == 0
1090 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2
)))
1091 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2
))) == INTEGER_CST
1092 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2
)),
1093 TYPE_SIZE (TREE_VALUE (args1
))))
1096 for (memb
= TYPE_FIELDS (TREE_VALUE (args2
));
1097 memb
; memb
= TREE_CHAIN (memb
))
1098 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (args1
)))
1107 /* comptypes said ok, but record if it said to warn. */
1111 args1
= TREE_CHAIN (args1
);
1112 args2
= TREE_CHAIN (args2
);
1116 /* Compute the size to increment a pointer by. */
1119 c_size_in_bytes (tree type
)
1121 enum tree_code code
= TREE_CODE (type
);
1123 if (code
== FUNCTION_TYPE
|| code
== VOID_TYPE
|| code
== ERROR_MARK
)
1124 return size_one_node
;
1126 if (!COMPLETE_OR_VOID_TYPE_P (type
))
1128 error ("arithmetic on pointer to an incomplete type");
1129 return size_one_node
;
1132 /* Convert in case a char is more than one unit. */
1133 return size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
1134 size_int (TYPE_PRECISION (char_type_node
)
1138 /* Return either DECL or its known constant value (if it has one). */
1141 decl_constant_value (tree decl
)
1143 if (/* Don't change a variable array bound or initial value to a constant
1144 in a place where a variable is invalid. Note that DECL_INITIAL
1145 isn't valid for a PARM_DECL. */
1146 current_function_decl
!= 0
1147 && TREE_CODE (decl
) != PARM_DECL
1148 && !TREE_THIS_VOLATILE (decl
)
1149 && TREE_READONLY (decl
)
1150 && DECL_INITIAL (decl
) != 0
1151 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
1152 /* This is invalid if initial value is not constant.
1153 If it has either a function call, a memory reference,
1154 or a variable, then re-evaluating it could give different results. */
1155 && TREE_CONSTANT (DECL_INITIAL (decl
))
1156 /* Check for cases where this is sub-optimal, even though valid. */
1157 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1158 return DECL_INITIAL (decl
);
1162 /* Return either DECL or its known constant value (if it has one), but
1163 return DECL if pedantic or DECL has mode BLKmode. This is for
1164 bug-compatibility with the old behavior of decl_constant_value
1165 (before GCC 3.0); every use of this function is a bug and it should
1166 be removed before GCC 3.1. It is not appropriate to use pedantic
1167 in a way that affects optimization, and BLKmode is probably not the
1168 right test for avoiding misoptimizations either. */
1171 decl_constant_value_for_broken_optimization (tree decl
)
1173 if (pedantic
|| DECL_MODE (decl
) == BLKmode
)
1176 return decl_constant_value (decl
);
1180 /* Perform the default conversion of arrays and functions to pointers.
1181 Return the result of converting EXP. For any other expression, just
1185 default_function_array_conversion (tree exp
)
1188 tree type
= TREE_TYPE (exp
);
1189 enum tree_code code
= TREE_CODE (type
);
1192 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1195 Do not use STRIP_NOPS here! It will remove conversions from pointer
1196 to integer and cause infinite recursion. */
1198 while (TREE_CODE (exp
) == NON_LVALUE_EXPR
1199 || (TREE_CODE (exp
) == NOP_EXPR
1200 && TREE_TYPE (TREE_OPERAND (exp
, 0)) == TREE_TYPE (exp
)))
1202 if (TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1204 exp
= TREE_OPERAND (exp
, 0);
1207 if (TREE_NO_WARNING (orig_exp
))
1208 TREE_NO_WARNING (exp
) = 1;
1210 if (code
== FUNCTION_TYPE
)
1212 return build_unary_op (ADDR_EXPR
, exp
, 0);
1214 if (code
== ARRAY_TYPE
)
1217 tree restype
= TREE_TYPE (type
);
1223 if (REFERENCE_CLASS_P (exp
) || DECL_P (exp
))
1225 constp
= TREE_READONLY (exp
);
1226 volatilep
= TREE_THIS_VOLATILE (exp
);
1229 if (TYPE_QUALS (type
) || constp
|| volatilep
)
1231 = c_build_qualified_type (restype
,
1233 | (constp
* TYPE_QUAL_CONST
)
1234 | (volatilep
* TYPE_QUAL_VOLATILE
));
1236 if (TREE_CODE (exp
) == INDIRECT_REF
)
1237 return convert (build_pointer_type (restype
),
1238 TREE_OPERAND (exp
, 0));
1240 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1242 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
1243 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
1244 TREE_OPERAND (exp
, 0), op1
);
1247 lvalue_array_p
= !not_lvalue
&& lvalue_p (exp
);
1248 if (!flag_isoc99
&& !lvalue_array_p
)
1250 /* Before C99, non-lvalue arrays do not decay to pointers.
1251 Normally, using such an array would be invalid; but it can
1252 be used correctly inside sizeof or as a statement expression.
1253 Thus, do not give an error here; an error will result later. */
1257 ptrtype
= build_pointer_type (restype
);
1259 if (TREE_CODE (exp
) == VAR_DECL
)
1261 /* We are making an ADDR_EXPR of ptrtype. This is a valid
1262 ADDR_EXPR because it's the best way of representing what
1263 happens in C when we take the address of an array and place
1264 it in a pointer to the element type. */
1265 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1266 if (!c_mark_addressable (exp
))
1267 return error_mark_node
;
1268 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1271 /* This way is better for a COMPONENT_REF since it can
1272 simplify the offset for a component. */
1273 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1274 return convert (ptrtype
, adr
);
1279 /* Perform default promotions for C data used in expressions.
1280 Arrays and functions are converted to pointers;
1281 enumeral types or short or char, to int.
1282 In addition, manifest constants symbols are replaced by their values. */
1285 default_conversion (tree exp
)
1288 tree type
= TREE_TYPE (exp
);
1289 enum tree_code code
= TREE_CODE (type
);
1291 if (code
== FUNCTION_TYPE
|| code
== ARRAY_TYPE
)
1292 return default_function_array_conversion (exp
);
1294 /* Constants can be used directly unless they're not loadable. */
1295 if (TREE_CODE (exp
) == CONST_DECL
)
1296 exp
= DECL_INITIAL (exp
);
1298 /* Replace a nonvolatile const static variable with its value unless
1299 it is an array, in which case we must be sure that taking the
1300 address of the array produces consistent results. */
1301 else if (optimize
&& TREE_CODE (exp
) == VAR_DECL
&& code
!= ARRAY_TYPE
)
1303 exp
= decl_constant_value_for_broken_optimization (exp
);
1304 type
= TREE_TYPE (exp
);
1307 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1310 Do not use STRIP_NOPS here! It will remove conversions from pointer
1311 to integer and cause infinite recursion. */
1313 while (TREE_CODE (exp
) == NON_LVALUE_EXPR
1314 || (TREE_CODE (exp
) == NOP_EXPR
1315 && TREE_TYPE (TREE_OPERAND (exp
, 0)) == TREE_TYPE (exp
)))
1316 exp
= TREE_OPERAND (exp
, 0);
1318 if (TREE_NO_WARNING (orig_exp
))
1319 TREE_NO_WARNING (exp
) = 1;
1321 /* Normally convert enums to int,
1322 but convert wide enums to something wider. */
1323 if (code
== ENUMERAL_TYPE
)
1325 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
1326 TYPE_PRECISION (integer_type_node
)),
1327 ((TYPE_PRECISION (type
)
1328 >= TYPE_PRECISION (integer_type_node
))
1329 && TYPE_UNSIGNED (type
)));
1331 return convert (type
, exp
);
1334 if (TREE_CODE (exp
) == COMPONENT_REF
1335 && DECL_C_BIT_FIELD (TREE_OPERAND (exp
, 1))
1336 /* If it's thinner than an int, promote it like a
1337 c_promoting_integer_type_p, otherwise leave it alone. */
1338 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp
, 1)),
1339 TYPE_PRECISION (integer_type_node
)))
1340 return convert (integer_type_node
, exp
);
1342 if (c_promoting_integer_type_p (type
))
1344 /* Preserve unsignedness if not really getting any wider. */
1345 if (TYPE_UNSIGNED (type
)
1346 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1347 return convert (unsigned_type_node
, exp
);
1349 return convert (integer_type_node
, exp
);
1352 if (code
== VOID_TYPE
)
1354 error ("void value not ignored as it ought to be");
1355 return error_mark_node
;
1360 /* Look up COMPONENT in a structure or union DECL.
1362 If the component name is not found, returns NULL_TREE. Otherwise,
1363 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1364 stepping down the chain to the component, which is in the last
1365 TREE_VALUE of the list. Normally the list is of length one, but if
1366 the component is embedded within (nested) anonymous structures or
1367 unions, the list steps down the chain to the component. */
1370 lookup_field (tree decl
, tree component
)
1372 tree type
= TREE_TYPE (decl
);
1375 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1376 to the field elements. Use a binary search on this array to quickly
1377 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1378 will always be set for structures which have many elements. */
1380 if (TYPE_LANG_SPECIFIC (type
) && TYPE_LANG_SPECIFIC (type
)->s
)
1383 tree
*field_array
= &TYPE_LANG_SPECIFIC (type
)->s
->elts
[0];
1385 field
= TYPE_FIELDS (type
);
1387 top
= TYPE_LANG_SPECIFIC (type
)->s
->len
;
1388 while (top
- bot
> 1)
1390 half
= (top
- bot
+ 1) >> 1;
1391 field
= field_array
[bot
+half
];
1393 if (DECL_NAME (field
) == NULL_TREE
)
1395 /* Step through all anon unions in linear fashion. */
1396 while (DECL_NAME (field_array
[bot
]) == NULL_TREE
)
1398 field
= field_array
[bot
++];
1399 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
1400 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
1402 tree anon
= lookup_field (field
, component
);
1405 return tree_cons (NULL_TREE
, field
, anon
);
1409 /* Entire record is only anon unions. */
1413 /* Restart the binary search, with new lower bound. */
1417 if (DECL_NAME (field
) == component
)
1419 if (DECL_NAME (field
) < component
)
1425 if (DECL_NAME (field_array
[bot
]) == component
)
1426 field
= field_array
[bot
];
1427 else if (DECL_NAME (field
) != component
)
1432 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1434 if (DECL_NAME (field
) == NULL_TREE
1435 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
1436 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
))
1438 tree anon
= lookup_field (field
, component
);
1441 return tree_cons (NULL_TREE
, field
, anon
);
1444 if (DECL_NAME (field
) == component
)
1448 if (field
== NULL_TREE
)
1452 return tree_cons (NULL_TREE
, field
, NULL_TREE
);
1455 /* Make an expression to refer to the COMPONENT field of
1456 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1459 build_component_ref (tree datum
, tree component
)
1461 tree type
= TREE_TYPE (datum
);
1462 enum tree_code code
= TREE_CODE (type
);
1466 if (!objc_is_public (datum
, component
))
1467 return error_mark_node
;
1469 /* See if there is a field or component with name COMPONENT. */
1471 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
1473 if (!COMPLETE_TYPE_P (type
))
1475 c_incomplete_type_error (NULL_TREE
, type
);
1476 return error_mark_node
;
1479 field
= lookup_field (datum
, component
);
1483 error ("%qT has no member named %qs", type
,
1484 IDENTIFIER_POINTER (component
));
1485 return error_mark_node
;
1488 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1489 This might be better solved in future the way the C++ front
1490 end does it - by giving the anonymous entities each a
1491 separate name and type, and then have build_component_ref
1492 recursively call itself. We can't do that here. */
1495 tree subdatum
= TREE_VALUE (field
);
1497 if (TREE_TYPE (subdatum
) == error_mark_node
)
1498 return error_mark_node
;
1500 ref
= build3 (COMPONENT_REF
, TREE_TYPE (subdatum
), datum
, subdatum
,
1502 if (TREE_READONLY (datum
) || TREE_READONLY (subdatum
))
1503 TREE_READONLY (ref
) = 1;
1504 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (subdatum
))
1505 TREE_THIS_VOLATILE (ref
) = 1;
1507 if (TREE_DEPRECATED (subdatum
))
1508 warn_deprecated_use (subdatum
);
1512 field
= TREE_CHAIN (field
);
1518 else if (code
!= ERROR_MARK
)
1519 error ("request for member %qs in something not a structure or union",
1520 IDENTIFIER_POINTER (component
));
1522 return error_mark_node
;
1525 /* Given an expression PTR for a pointer, return an expression
1526 for the value pointed to.
1527 ERRORSTRING is the name of the operator to appear in error messages. */
1530 build_indirect_ref (tree ptr
, const char *errorstring
)
1532 tree pointer
= default_conversion (ptr
);
1533 tree type
= TREE_TYPE (pointer
);
1535 if (TREE_CODE (type
) == POINTER_TYPE
)
1537 if (TREE_CODE (pointer
) == ADDR_EXPR
1538 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1539 == TREE_TYPE (type
)))
1540 return TREE_OPERAND (pointer
, 0);
1543 tree t
= TREE_TYPE (type
);
1544 tree ref
= build1 (INDIRECT_REF
, TYPE_MAIN_VARIANT (t
), pointer
);
1546 if (!COMPLETE_OR_VOID_TYPE_P (t
) && TREE_CODE (t
) != ARRAY_TYPE
)
1548 error ("dereferencing pointer to incomplete type");
1549 return error_mark_node
;
1551 if (VOID_TYPE_P (t
) && skip_evaluation
== 0)
1552 warning ("dereferencing %<void *%> pointer");
1554 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1555 so that we get the proper error message if the result is used
1556 to assign to. Also, &* is supposed to be a no-op.
1557 And ANSI C seems to specify that the type of the result
1558 should be the const type. */
1559 /* A de-reference of a pointer to const is not a const. It is valid
1560 to change it via some other pointer. */
1561 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1562 TREE_SIDE_EFFECTS (ref
)
1563 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
1564 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1568 else if (TREE_CODE (pointer
) != ERROR_MARK
)
1569 error ("invalid type argument of %qs", errorstring
);
1570 return error_mark_node
;
1573 /* This handles expressions of the form "a[i]", which denotes
1576 This is logically equivalent in C to *(a+i), but we may do it differently.
1577 If A is a variable or a member, we generate a primitive ARRAY_REF.
1578 This avoids forcing the array out of registers, and can work on
1579 arrays that are not lvalues (for example, members of structures returned
1583 build_array_ref (tree array
, tree index
)
1585 bool swapped
= false;
1586 if (TREE_TYPE (array
) == error_mark_node
1587 || TREE_TYPE (index
) == error_mark_node
)
1588 return error_mark_node
;
1590 if (TREE_CODE (TREE_TYPE (array
)) != ARRAY_TYPE
1591 && TREE_CODE (TREE_TYPE (array
)) != POINTER_TYPE
)
1594 if (TREE_CODE (TREE_TYPE (index
)) != ARRAY_TYPE
1595 && TREE_CODE (TREE_TYPE (index
)) != POINTER_TYPE
)
1597 error ("subscripted value is neither array nor pointer");
1598 return error_mark_node
;
1606 if (!INTEGRAL_TYPE_P (TREE_TYPE (index
)))
1608 error ("array subscript is not an integer");
1609 return error_mark_node
;
1612 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array
))) == FUNCTION_TYPE
)
1614 error ("subscripted value is pointer to function");
1615 return error_mark_node
;
1618 /* Subscripting with type char is likely to lose on a machine where
1619 chars are signed. So warn on any machine, but optionally. Don't
1620 warn for unsigned char since that type is safe. Don't warn for
1621 signed char because anyone who uses that must have done so
1622 deliberately. ??? Existing practice has also been to warn only
1623 when the char index is syntactically the index, not for
1625 if (warn_char_subscripts
&& !swapped
1626 && TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
)
1627 warning ("array subscript has type %<char%>");
1629 /* Apply default promotions *after* noticing character types. */
1630 index
= default_conversion (index
);
1632 gcc_assert (TREE_CODE (TREE_TYPE (index
)) == INTEGER_TYPE
);
1634 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
1638 /* An array that is indexed by a non-constant
1639 cannot be stored in a register; we must be able to do
1640 address arithmetic on its address.
1641 Likewise an array of elements of variable size. */
1642 if (TREE_CODE (index
) != INTEGER_CST
1643 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
1644 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1646 if (!c_mark_addressable (array
))
1647 return error_mark_node
;
1649 /* An array that is indexed by a constant value which is not within
1650 the array bounds cannot be stored in a register either; because we
1651 would get a crash in store_bit_field/extract_bit_field when trying
1652 to access a non-existent part of the register. */
1653 if (TREE_CODE (index
) == INTEGER_CST
1654 && TYPE_DOMAIN (TREE_TYPE (array
))
1655 && !int_fits_type_p (index
, TYPE_DOMAIN (TREE_TYPE (array
))))
1657 if (!c_mark_addressable (array
))
1658 return error_mark_node
;
1664 while (TREE_CODE (foo
) == COMPONENT_REF
)
1665 foo
= TREE_OPERAND (foo
, 0);
1666 if (TREE_CODE (foo
) == VAR_DECL
&& C_DECL_REGISTER (foo
))
1667 pedwarn ("ISO C forbids subscripting %<register%> array");
1668 else if (!flag_isoc99
&& !lvalue_p (foo
))
1669 pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1672 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
1673 rval
= build4 (ARRAY_REF
, type
, array
, index
, NULL_TREE
, NULL_TREE
);
1674 /* Array ref is const/volatile if the array elements are
1675 or if the array is. */
1676 TREE_READONLY (rval
)
1677 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1678 | TREE_READONLY (array
));
1679 TREE_SIDE_EFFECTS (rval
)
1680 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1681 | TREE_SIDE_EFFECTS (array
));
1682 TREE_THIS_VOLATILE (rval
)
1683 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1684 /* This was added by rms on 16 Nov 91.
1685 It fixes vol struct foo *a; a->elts[1]
1686 in an inline function.
1687 Hope it doesn't break something else. */
1688 | TREE_THIS_VOLATILE (array
));
1689 return require_complete_type (fold (rval
));
1693 tree ar
= default_conversion (array
);
1695 if (ar
== error_mark_node
)
1698 gcc_assert (TREE_CODE (TREE_TYPE (ar
)) == POINTER_TYPE
);
1699 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar
))) != FUNCTION_TYPE
);
1701 return build_indirect_ref (build_binary_op (PLUS_EXPR
, ar
, index
, 0),
1706 /* Build an external reference to identifier ID. FUN indicates
1707 whether this will be used for a function call. */
1709 build_external_ref (tree id
, int fun
)
1712 tree decl
= lookup_name (id
);
1714 /* In Objective-C, an instance variable (ivar) may be preferred to
1715 whatever lookup_name() found. */
1716 decl
= objc_lookup_ivar (decl
, id
);
1718 if (decl
&& decl
!= error_mark_node
)
1721 /* Implicit function declaration. */
1722 ref
= implicitly_declare (id
);
1723 else if (decl
== error_mark_node
)
1724 /* Don't complain about something that's already been
1725 complained about. */
1726 return error_mark_node
;
1729 undeclared_variable (id
);
1730 return error_mark_node
;
1733 if (TREE_TYPE (ref
) == error_mark_node
)
1734 return error_mark_node
;
1736 if (TREE_DEPRECATED (ref
))
1737 warn_deprecated_use (ref
);
1739 if (!skip_evaluation
)
1740 assemble_external (ref
);
1741 TREE_USED (ref
) = 1;
1743 if (TREE_CODE (ref
) == FUNCTION_DECL
&& !in_alignof
)
1745 if (!in_sizeof
&& !in_typeof
)
1746 C_DECL_USED (ref
) = 1;
1747 else if (DECL_INITIAL (ref
) == 0
1748 && DECL_EXTERNAL (ref
)
1749 && !TREE_PUBLIC (ref
))
1750 record_maybe_used_decl (ref
);
1753 if (TREE_CODE (ref
) == CONST_DECL
)
1755 ref
= DECL_INITIAL (ref
);
1756 TREE_CONSTANT (ref
) = 1;
1757 TREE_INVARIANT (ref
) = 1;
1759 else if (current_function_decl
!= 0
1760 && !DECL_FILE_SCOPE_P (current_function_decl
)
1761 && (TREE_CODE (ref
) == VAR_DECL
1762 || TREE_CODE (ref
) == PARM_DECL
1763 || TREE_CODE (ref
) == FUNCTION_DECL
))
1765 tree context
= decl_function_context (ref
);
1767 if (context
!= 0 && context
!= current_function_decl
)
1768 DECL_NONLOCAL (ref
) = 1;
1774 /* Record details of decls possibly used inside sizeof or typeof. */
1775 struct maybe_used_decl
1779 /* The level seen at (in_sizeof + in_typeof). */
1781 /* The next one at this level or above, or NULL. */
1782 struct maybe_used_decl
*next
;
1785 static struct maybe_used_decl
*maybe_used_decls
;
1787 /* Record that DECL, an undefined static function reference seen
1788 inside sizeof or typeof, might be used if the operand of sizeof is
1789 a VLA type or the operand of typeof is a variably modified
1793 record_maybe_used_decl (tree decl
)
1795 struct maybe_used_decl
*t
= XOBNEW (&parser_obstack
, struct maybe_used_decl
);
1797 t
->level
= in_sizeof
+ in_typeof
;
1798 t
->next
= maybe_used_decls
;
1799 maybe_used_decls
= t
;
1802 /* Pop the stack of decls possibly used inside sizeof or typeof. If
1803 USED is false, just discard them. If it is true, mark them used
1804 (if no longer inside sizeof or typeof) or move them to the next
1805 level up (if still inside sizeof or typeof). */
1808 pop_maybe_used (bool used
)
1810 struct maybe_used_decl
*p
= maybe_used_decls
;
1811 int cur_level
= in_sizeof
+ in_typeof
;
1812 while (p
&& p
->level
> cur_level
)
1817 C_DECL_USED (p
->decl
) = 1;
1819 p
->level
= cur_level
;
1823 if (!used
|| cur_level
== 0)
1824 maybe_used_decls
= p
;
1827 /* Return the result of sizeof applied to EXPR. */
1830 c_expr_sizeof_expr (struct c_expr expr
)
1833 if (expr
.value
== error_mark_node
)
1835 ret
.value
= error_mark_node
;
1836 ret
.original_code
= ERROR_MARK
;
1837 pop_maybe_used (false);
1841 ret
.value
= c_sizeof (TREE_TYPE (expr
.value
));
1842 ret
.original_code
= ERROR_MARK
;
1843 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr
.value
)));
1848 /* Return the result of sizeof applied to T, a structure for the type
1849 name passed to sizeof (rather than the type itself). */
1852 c_expr_sizeof_type (struct c_type_name
*t
)
1856 type
= groktypename (t
);
1857 ret
.value
= c_sizeof (type
);
1858 ret
.original_code
= ERROR_MARK
;
1859 pop_maybe_used (C_TYPE_VARIABLE_SIZE (type
));
1863 /* Build a function call to function FUNCTION with parameters PARAMS.
1864 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1865 TREE_VALUE of each node is a parameter-expression.
1866 FUNCTION's data type may be a function type or a pointer-to-function. */
1869 build_function_call (tree function
, tree params
)
1871 tree fntype
, fundecl
= 0;
1872 tree coerced_params
;
1873 tree name
= NULL_TREE
, result
;
1876 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1877 STRIP_TYPE_NOPS (function
);
1879 /* Convert anything with function type to a pointer-to-function. */
1880 if (TREE_CODE (function
) == FUNCTION_DECL
)
1882 name
= DECL_NAME (function
);
1884 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1885 (because calling an inline function does not mean the function
1886 needs to be separately compiled). */
1887 fntype
= build_type_variant (TREE_TYPE (function
),
1888 TREE_READONLY (function
),
1889 TREE_THIS_VOLATILE (function
));
1891 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
1894 function
= default_conversion (function
);
1896 fntype
= TREE_TYPE (function
);
1898 if (TREE_CODE (fntype
) == ERROR_MARK
)
1899 return error_mark_node
;
1901 if (!(TREE_CODE (fntype
) == POINTER_TYPE
1902 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
1904 error ("called object %qE is not a function", function
);
1905 return error_mark_node
;
1908 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
1909 current_function_returns_abnormally
= 1;
1911 /* fntype now gets the type of function pointed to. */
1912 fntype
= TREE_TYPE (fntype
);
1914 /* Check that the function is called through a compatible prototype.
1915 If it is not, replace the call by a trap, wrapped up in a compound
1916 expression if necessary. This has the nice side-effect to prevent
1917 the tree-inliner from generating invalid assignment trees which may
1918 blow up in the RTL expander later.
1920 ??? This doesn't work for Objective-C because objc_comptypes
1921 refuses to compare function prototypes, yet the compiler appears
1922 to build calls that are flagged as invalid by C's comptypes. */
1923 if (!c_dialect_objc ()
1924 && TREE_CODE (function
) == NOP_EXPR
1925 && TREE_CODE (tem
= TREE_OPERAND (function
, 0)) == ADDR_EXPR
1926 && TREE_CODE (tem
= TREE_OPERAND (tem
, 0)) == FUNCTION_DECL
1927 && !comptypes (fntype
, TREE_TYPE (tem
)))
1929 tree return_type
= TREE_TYPE (fntype
);
1930 tree trap
= build_function_call (built_in_decls
[BUILT_IN_TRAP
],
1933 /* This situation leads to run-time undefined behavior. We can't,
1934 therefore, simply error unless we can prove that all possible
1935 executions of the program must execute the code. */
1936 warning ("function called through a non-compatible type");
1938 /* We can, however, treat "undefined" any way we please.
1939 Call abort to encourage the user to fix the program. */
1940 inform ("if this code is reached, the program will abort");
1942 if (VOID_TYPE_P (return_type
))
1948 if (AGGREGATE_TYPE_P (return_type
))
1949 rhs
= build_compound_literal (return_type
,
1950 build_constructor (return_type
,
1953 rhs
= fold (build1 (NOP_EXPR
, return_type
, integer_zero_node
));
1955 return build2 (COMPOUND_EXPR
, return_type
, trap
, rhs
);
1959 /* Convert the parameters to the types declared in the
1960 function prototype, or apply default promotions. */
1963 = convert_arguments (TYPE_ARG_TYPES (fntype
), params
, function
, fundecl
);
1965 if (coerced_params
== error_mark_node
)
1966 return error_mark_node
;
1968 /* Check that the arguments to the function are valid. */
1970 check_function_arguments (TYPE_ATTRIBUTES (fntype
), coerced_params
);
1972 result
= build3 (CALL_EXPR
, TREE_TYPE (fntype
),
1973 function
, coerced_params
, NULL_TREE
);
1974 TREE_SIDE_EFFECTS (result
) = 1;
1976 if (require_constant_value
)
1978 result
= fold_initializer (result
);
1980 if (TREE_CONSTANT (result
)
1981 && (name
== NULL_TREE
1982 || strncmp (IDENTIFIER_POINTER (name
), "__builtin_", 10) != 0))
1983 pedwarn_init ("initializer element is not constant");
1986 result
= fold (result
);
1988 if (VOID_TYPE_P (TREE_TYPE (result
)))
1990 return require_complete_type (result
);
1993 /* Convert the argument expressions in the list VALUES
1994 to the types in the list TYPELIST. The result is a list of converted
1995 argument expressions, unless there are too few arguments in which
1996 case it is error_mark_node.
1998 If TYPELIST is exhausted, or when an element has NULL as its type,
1999 perform the default conversions.
2001 PARMLIST is the chain of parm decls for the function being called.
2002 It may be 0, if that info is not available.
2003 It is used only for generating error messages.
2005 FUNCTION is a tree for the called function. It is used only for
2006 error messages, where it is formatted with %qE.
2008 This is also where warnings about wrong number of args are generated.
2010 Both VALUES and the returned value are chains of TREE_LIST nodes
2011 with the elements of the list in the TREE_VALUE slots of those nodes. */
2014 convert_arguments (tree typelist
, tree values
, tree function
, tree fundecl
)
2016 tree typetail
, valtail
;
2021 /* Change pointer to function to the function itself for
2023 if (TREE_CODE (function
) == ADDR_EXPR
2024 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
2025 function
= TREE_OPERAND (function
, 0);
2027 /* Handle an ObjC selector specially for diagnostics. */
2028 selector
= objc_message_selector ();
2030 /* Scan the given expressions and types, producing individual
2031 converted arguments and pushing them on RESULT in reverse order. */
2033 for (valtail
= values
, typetail
= typelist
, parmnum
= 0;
2035 valtail
= TREE_CHAIN (valtail
), parmnum
++)
2037 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2038 tree val
= TREE_VALUE (valtail
);
2039 tree rname
= function
;
2040 int argnum
= parmnum
+ 1;
2042 if (type
== void_type_node
)
2044 error ("too many arguments to function %qE", function
);
2048 if (selector
&& argnum
> 2)
2054 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
2055 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
2056 to convert automatically to a pointer. */
2057 if (TREE_CODE (val
) == NON_LVALUE_EXPR
)
2058 val
= TREE_OPERAND (val
, 0);
2060 val
= default_function_array_conversion (val
);
2062 val
= require_complete_type (val
);
2066 /* Formal parm type is specified by a function prototype. */
2069 if (!COMPLETE_TYPE_P (type
))
2071 error ("type of formal parameter %d is incomplete", parmnum
+ 1);
2076 /* Optionally warn about conversions that
2077 differ from the default conversions. */
2078 if (warn_conversion
|| warn_traditional
)
2080 unsigned int formal_prec
= TYPE_PRECISION (type
);
2082 if (INTEGRAL_TYPE_P (type
)
2083 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2084 warning ("passing argument %d of %qE as integer "
2085 "rather than floating due to prototype",
2087 if (INTEGRAL_TYPE_P (type
)
2088 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
2089 warning ("passing argument %d of %qE as integer "
2090 "rather than complex due to prototype",
2092 else if (TREE_CODE (type
) == COMPLEX_TYPE
2093 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2094 warning ("passing argument %d of %qE as complex "
2095 "rather than floating due to prototype",
2097 else if (TREE_CODE (type
) == REAL_TYPE
2098 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2099 warning ("passing argument %d of %qE as floating "
2100 "rather than integer due to prototype",
2102 else if (TREE_CODE (type
) == COMPLEX_TYPE
2103 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2104 warning ("passing argument %d of %qE as complex "
2105 "rather than integer due to prototype",
2107 else if (TREE_CODE (type
) == REAL_TYPE
2108 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
2109 warning ("passing argument %d of %qE as floating "
2110 "rather than complex due to prototype",
2112 /* ??? At some point, messages should be written about
2113 conversions between complex types, but that's too messy
2115 else if (TREE_CODE (type
) == REAL_TYPE
2116 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2118 /* Warn if any argument is passed as `float',
2119 since without a prototype it would be `double'. */
2120 if (formal_prec
== TYPE_PRECISION (float_type_node
))
2121 warning ("passing argument %d of %qE as %<float%> "
2122 "rather than %<double%> due to prototype",
2125 /* Detect integer changing in width or signedness.
2126 These warnings are only activated with
2127 -Wconversion, not with -Wtraditional. */
2128 else if (warn_conversion
&& INTEGRAL_TYPE_P (type
)
2129 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2131 tree would_have_been
= default_conversion (val
);
2132 tree type1
= TREE_TYPE (would_have_been
);
2134 if (TREE_CODE (type
) == ENUMERAL_TYPE
2135 && (TYPE_MAIN_VARIANT (type
)
2136 == TYPE_MAIN_VARIANT (TREE_TYPE (val
))))
2137 /* No warning if function asks for enum
2138 and the actual arg is that enum type. */
2140 else if (formal_prec
!= TYPE_PRECISION (type1
))
2141 warning ("passing argument %d of %qE with different "
2142 "width due to prototype", argnum
, rname
);
2143 else if (TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (type1
))
2145 /* Don't complain if the formal parameter type
2146 is an enum, because we can't tell now whether
2147 the value was an enum--even the same enum. */
2148 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2150 else if (TREE_CODE (val
) == INTEGER_CST
2151 && int_fits_type_p (val
, type
))
2152 /* Change in signedness doesn't matter
2153 if a constant value is unaffected. */
2155 /* Likewise for a constant in a NOP_EXPR. */
2156 else if (TREE_CODE (val
) == NOP_EXPR
2157 && TREE_CODE (TREE_OPERAND (val
, 0)) == INTEGER_CST
2158 && int_fits_type_p (TREE_OPERAND (val
, 0), type
))
2160 /* If the value is extended from a narrower
2161 unsigned type, it doesn't matter whether we
2162 pass it as signed or unsigned; the value
2163 certainly is the same either way. */
2164 else if (TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
)
2165 && TYPE_UNSIGNED (TREE_TYPE (val
)))
2167 else if (TYPE_UNSIGNED (type
))
2168 warning ("passing argument %d of %qE as unsigned "
2169 "due to prototype", argnum
, rname
);
2171 warning ("passing argument %d of %qE as signed "
2172 "due to prototype", argnum
, rname
);
2176 parmval
= convert_for_assignment (type
, val
, ic_argpass
,
2180 if (targetm
.calls
.promote_prototypes (fundecl
? TREE_TYPE (fundecl
) : 0)
2181 && INTEGRAL_TYPE_P (type
)
2182 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2183 parmval
= default_conversion (parmval
);
2185 result
= tree_cons (NULL_TREE
, parmval
, result
);
2187 else if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2188 && (TYPE_PRECISION (TREE_TYPE (val
))
2189 < TYPE_PRECISION (double_type_node
)))
2190 /* Convert `float' to `double'. */
2191 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2193 /* Convert `short' and `char' to full-size `int'. */
2194 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2197 typetail
= TREE_CHAIN (typetail
);
2200 if (typetail
!= 0 && TREE_VALUE (typetail
) != void_type_node
)
2202 error ("too few arguments to function %qE", function
);
2203 return error_mark_node
;
2206 return nreverse (result
);
2209 /* This is the entry point used by the parser
2210 for binary operators in the input.
2211 In addition to constructing the expression,
2212 we check for operands that were written with other binary operators
2213 in a way that is likely to confuse the user. */
2216 parser_build_binary_op (enum tree_code code
, struct c_expr arg1
,
2219 struct c_expr result
;
2221 enum tree_code code1
= arg1
.original_code
;
2222 enum tree_code code2
= arg2
.original_code
;
2224 result
.value
= build_binary_op (code
, arg1
.value
, arg2
.value
, 1);
2225 result
.original_code
= code
;
2227 if (TREE_CODE (result
.value
) == ERROR_MARK
)
2230 /* Check for cases such as x+y<<z which users are likely
2232 if (warn_parentheses
)
2234 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
2236 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2237 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2238 warning ("suggest parentheses around + or - inside shift");
2241 if (code
== TRUTH_ORIF_EXPR
)
2243 if (code1
== TRUTH_ANDIF_EXPR
2244 || code2
== TRUTH_ANDIF_EXPR
)
2245 warning ("suggest parentheses around && within ||");
2248 if (code
== BIT_IOR_EXPR
)
2250 if (code1
== BIT_AND_EXPR
|| code1
== BIT_XOR_EXPR
2251 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2252 || code2
== BIT_AND_EXPR
|| code2
== BIT_XOR_EXPR
2253 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2254 warning ("suggest parentheses around arithmetic in operand of |");
2255 /* Check cases like x|y==z */
2256 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2257 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2258 warning ("suggest parentheses around comparison in operand of |");
2261 if (code
== BIT_XOR_EXPR
)
2263 if (code1
== BIT_AND_EXPR
2264 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2265 || code2
== BIT_AND_EXPR
2266 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2267 warning ("suggest parentheses around arithmetic in operand of ^");
2268 /* Check cases like x^y==z */
2269 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2270 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2271 warning ("suggest parentheses around comparison in operand of ^");
2274 if (code
== BIT_AND_EXPR
)
2276 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2277 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2278 warning ("suggest parentheses around + or - in operand of &");
2279 /* Check cases like x&y==z */
2280 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2281 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2282 warning ("suggest parentheses around comparison in operand of &");
2284 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
2285 if (TREE_CODE_CLASS (code
) == tcc_comparison
2286 && (TREE_CODE_CLASS (code1
) == tcc_comparison
2287 || TREE_CODE_CLASS (code2
) == tcc_comparison
))
2288 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2292 unsigned_conversion_warning (result
.value
, arg1
.value
);
2293 unsigned_conversion_warning (result
.value
, arg2
.value
);
2294 overflow_warning (result
.value
);
2299 /* Return a tree for the difference of pointers OP0 and OP1.
2300 The resulting tree has type int. */
2303 pointer_diff (tree op0
, tree op1
)
2305 tree restype
= ptrdiff_type_node
;
2307 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
2308 tree con0
, con1
, lit0
, lit1
;
2309 tree orig_op1
= op1
;
2311 if (pedantic
|| warn_pointer_arith
)
2313 if (TREE_CODE (target_type
) == VOID_TYPE
)
2314 pedwarn ("pointer of type %<void *%> used in subtraction");
2315 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
2316 pedwarn ("pointer to a function used in subtraction");
2319 /* If the conversion to ptrdiff_type does anything like widening or
2320 converting a partial to an integral mode, we get a convert_expression
2321 that is in the way to do any simplifications.
2322 (fold-const.c doesn't know that the extra bits won't be needed.
2323 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2324 different mode in place.)
2325 So first try to find a common term here 'by hand'; we want to cover
2326 at least the cases that occur in legal static initializers. */
2327 con0
= TREE_CODE (op0
) == NOP_EXPR
? TREE_OPERAND (op0
, 0) : op0
;
2328 con1
= TREE_CODE (op1
) == NOP_EXPR
? TREE_OPERAND (op1
, 0) : op1
;
2330 if (TREE_CODE (con0
) == PLUS_EXPR
)
2332 lit0
= TREE_OPERAND (con0
, 1);
2333 con0
= TREE_OPERAND (con0
, 0);
2336 lit0
= integer_zero_node
;
2338 if (TREE_CODE (con1
) == PLUS_EXPR
)
2340 lit1
= TREE_OPERAND (con1
, 1);
2341 con1
= TREE_OPERAND (con1
, 0);
2344 lit1
= integer_zero_node
;
2346 if (operand_equal_p (con0
, con1
, 0))
2353 /* First do the subtraction as integers;
2354 then drop through to build the divide operator.
2355 Do not do default conversions on the minus operator
2356 in case restype is a short type. */
2358 op0
= build_binary_op (MINUS_EXPR
, convert (restype
, op0
),
2359 convert (restype
, op1
), 0);
2360 /* This generates an error if op1 is pointer to incomplete type. */
2361 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1
))))
2362 error ("arithmetic on pointer to an incomplete type");
2364 /* This generates an error if op0 is pointer to incomplete type. */
2365 op1
= c_size_in_bytes (target_type
);
2367 /* Divide by the size, in easiest possible way. */
2368 return fold (build2 (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
)));
2371 /* Construct and perhaps optimize a tree representation
2372 for a unary operation. CODE, a tree_code, specifies the operation
2373 and XARG is the operand.
2374 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2375 the default promotions (such as from short to int).
2376 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2377 allows non-lvalues; this is only used to handle conversion of non-lvalue
2378 arrays to pointers in C99. */
2381 build_unary_op (enum tree_code code
, tree xarg
, int flag
)
2383 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2386 enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
2388 int noconvert
= flag
;
2390 if (typecode
== ERROR_MARK
)
2391 return error_mark_node
;
2392 if (typecode
== ENUMERAL_TYPE
|| typecode
== BOOLEAN_TYPE
)
2393 typecode
= INTEGER_TYPE
;
2398 /* This is used for unary plus, because a CONVERT_EXPR
2399 is enough to prevent anybody from looking inside for
2400 associativity, but won't generate any code. */
2401 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2402 || typecode
== COMPLEX_TYPE
2403 || typecode
== VECTOR_TYPE
))
2405 error ("wrong type argument to unary plus");
2406 return error_mark_node
;
2408 else if (!noconvert
)
2409 arg
= default_conversion (arg
);
2410 arg
= non_lvalue (arg
);
2414 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2415 || typecode
== COMPLEX_TYPE
2416 || typecode
== VECTOR_TYPE
))
2418 error ("wrong type argument to unary minus");
2419 return error_mark_node
;
2421 else if (!noconvert
)
2422 arg
= default_conversion (arg
);
2426 if (typecode
== INTEGER_TYPE
|| typecode
== VECTOR_TYPE
)
2429 arg
= default_conversion (arg
);
2431 else if (typecode
== COMPLEX_TYPE
)
2435 pedwarn ("ISO C does not support %<~%> for complex conjugation");
2437 arg
= default_conversion (arg
);
2441 error ("wrong type argument to bit-complement");
2442 return error_mark_node
;
2447 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
2449 error ("wrong type argument to abs");
2450 return error_mark_node
;
2452 else if (!noconvert
)
2453 arg
= default_conversion (arg
);
2457 /* Conjugating a real value is a no-op, but allow it anyway. */
2458 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2459 || typecode
== COMPLEX_TYPE
))
2461 error ("wrong type argument to conjugation");
2462 return error_mark_node
;
2464 else if (!noconvert
)
2465 arg
= default_conversion (arg
);
2468 case TRUTH_NOT_EXPR
:
2469 if (typecode
!= INTEGER_TYPE
2470 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
2471 && typecode
!= COMPLEX_TYPE
2472 /* These will convert to a pointer. */
2473 && typecode
!= ARRAY_TYPE
&& typecode
!= FUNCTION_TYPE
)
2475 error ("wrong type argument to unary exclamation mark");
2476 return error_mark_node
;
2478 arg
= lang_hooks
.truthvalue_conversion (arg
);
2479 return invert_truthvalue (arg
);
2485 if (TREE_CODE (arg
) == COMPLEX_CST
)
2486 return TREE_REALPART (arg
);
2487 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2488 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2493 if (TREE_CODE (arg
) == COMPLEX_CST
)
2494 return TREE_IMAGPART (arg
);
2495 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2496 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2498 return convert (TREE_TYPE (arg
), integer_zero_node
);
2500 case PREINCREMENT_EXPR
:
2501 case POSTINCREMENT_EXPR
:
2502 case PREDECREMENT_EXPR
:
2503 case POSTDECREMENT_EXPR
:
2505 /* Increment or decrement the real part of the value,
2506 and don't change the imaginary part. */
2507 if (typecode
== COMPLEX_TYPE
)
2512 pedwarn ("ISO C does not support %<++%> and %<--%>"
2513 " on complex types");
2515 arg
= stabilize_reference (arg
);
2516 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
2517 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
2518 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
2519 build_unary_op (code
, real
, 1), imag
);
2522 /* Report invalid types. */
2524 if (typecode
!= POINTER_TYPE
2525 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
2527 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2528 error ("wrong type argument to increment");
2530 error ("wrong type argument to decrement");
2532 return error_mark_node
;
2537 tree result_type
= TREE_TYPE (arg
);
2539 arg
= get_unwidened (arg
, 0);
2540 argtype
= TREE_TYPE (arg
);
2542 /* Compute the increment. */
2544 if (typecode
== POINTER_TYPE
)
2546 /* If pointer target is an undefined struct,
2547 we just cannot know how to do the arithmetic. */
2548 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type
)))
2550 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2551 error ("increment of pointer to unknown structure");
2553 error ("decrement of pointer to unknown structure");
2555 else if ((pedantic
|| warn_pointer_arith
)
2556 && (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
2557 || TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
))
2559 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2560 pedwarn ("wrong type argument to increment");
2562 pedwarn ("wrong type argument to decrement");
2565 inc
= c_size_in_bytes (TREE_TYPE (result_type
));
2568 inc
= integer_one_node
;
2570 inc
= convert (argtype
, inc
);
2572 /* Complain about anything else that is not a true lvalue. */
2573 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
2574 || code
== POSTINCREMENT_EXPR
)
2577 return error_mark_node
;
2579 /* Report a read-only lvalue. */
2580 if (TREE_READONLY (arg
))
2581 readonly_error (arg
,
2582 ((code
== PREINCREMENT_EXPR
2583 || code
== POSTINCREMENT_EXPR
)
2584 ? lv_increment
: lv_decrement
));
2586 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
2587 val
= boolean_increment (code
, arg
);
2589 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
2590 TREE_SIDE_EFFECTS (val
) = 1;
2591 val
= convert (result_type
, val
);
2592 if (TREE_CODE (val
) != code
)
2593 TREE_NO_WARNING (val
) = 1;
2598 /* Note that this operation never does default_conversion. */
2600 /* Let &* cancel out to simplify resulting code. */
2601 if (TREE_CODE (arg
) == INDIRECT_REF
)
2603 /* Don't let this be an lvalue. */
2604 if (lvalue_p (TREE_OPERAND (arg
, 0)))
2605 return non_lvalue (TREE_OPERAND (arg
, 0));
2606 return TREE_OPERAND (arg
, 0);
2609 /* For &x[y], return x+y */
2610 if (TREE_CODE (arg
) == ARRAY_REF
)
2612 if (!c_mark_addressable (TREE_OPERAND (arg
, 0)))
2613 return error_mark_node
;
2614 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
2615 TREE_OPERAND (arg
, 1), 1);
2618 /* Anything not already handled and not a true memory reference
2619 or a non-lvalue array is an error. */
2620 else if (typecode
!= FUNCTION_TYPE
&& !flag
2621 && !lvalue_or_else (arg
, lv_addressof
))
2622 return error_mark_node
;
2624 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
2625 argtype
= TREE_TYPE (arg
);
2627 /* If the lvalue is const or volatile, merge that into the type
2628 to which the address will point. Note that you can't get a
2629 restricted pointer by taking the address of something, so we
2630 only have to deal with `const' and `volatile' here. */
2631 if ((DECL_P (arg
) || REFERENCE_CLASS_P (arg
))
2632 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
)))
2633 argtype
= c_build_type_variant (argtype
,
2634 TREE_READONLY (arg
),
2635 TREE_THIS_VOLATILE (arg
));
2637 if (!c_mark_addressable (arg
))
2638 return error_mark_node
;
2640 gcc_assert (TREE_CODE (arg
) != COMPONENT_REF
2641 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)));
2643 argtype
= build_pointer_type (argtype
);
2645 /* ??? Cope with user tricks that amount to offsetof. Delete this
2646 when we have proper support for integer constant expressions. */
2647 val
= get_base_address (arg
);
2648 if (val
&& TREE_CODE (val
) == INDIRECT_REF
2649 && integer_zerop (TREE_OPERAND (val
, 0)))
2650 return fold_convert (argtype
, fold_offsetof (arg
));
2652 val
= build1 (ADDR_EXPR
, argtype
, arg
);
2654 if (TREE_CODE (arg
) == COMPOUND_LITERAL_EXPR
)
2655 TREE_INVARIANT (val
) = TREE_CONSTANT (val
) = 1;
2664 argtype
= TREE_TYPE (arg
);
2665 val
= build1 (code
, argtype
, arg
);
2666 return require_constant_value
? fold_initializer (val
) : fold (val
);
2669 /* Return nonzero if REF is an lvalue valid for this language.
2670 Lvalues can be assigned, unless their type has TYPE_READONLY.
2671 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
2676 enum tree_code code
= TREE_CODE (ref
);
2683 return lvalue_p (TREE_OPERAND (ref
, 0));
2685 case COMPOUND_LITERAL_EXPR
:
2695 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
2696 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
2699 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
2706 /* Give an error for storing in something that is 'const'. */
2709 readonly_error (tree arg
, enum lvalue_use use
)
2711 gcc_assert (use
== lv_assign
|| use
== lv_increment
|| use
== lv_decrement
);
2712 /* Using this macro rather than (for example) arrays of messages
2713 ensures that all the format strings are checked at compile
2715 #define READONLY_MSG(A, I, D) (use == lv_assign \
2717 : (use == lv_increment ? (I) : (D)))
2718 if (TREE_CODE (arg
) == COMPONENT_REF
)
2720 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
2721 readonly_error (TREE_OPERAND (arg
, 0), use
);
2723 error (READONLY_MSG (N_("assignment of read-only member %qs"),
2724 N_("increment of read-only member %qs"),
2725 N_("decrement of read-only member %qs")),
2726 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg
, 1))));
2728 else if (TREE_CODE (arg
) == VAR_DECL
)
2729 error (READONLY_MSG (N_("assignment of read-only variable %qs"),
2730 N_("increment of read-only variable %qs"),
2731 N_("decrement of read-only variable %qs")),
2732 IDENTIFIER_POINTER (DECL_NAME (arg
)));
2734 error (READONLY_MSG (N_("assignment of read-only location"),
2735 N_("increment of read-only location"),
2736 N_("decrement of read-only location")));
2739 /* Mark EXP saying that we need to be able to take the
2740 address of it; it should not be allocated in a register.
2741 Returns true if successful. */
2744 c_mark_addressable (tree exp
)
2749 switch (TREE_CODE (x
))
2752 if (DECL_C_BIT_FIELD (TREE_OPERAND (x
, 1)))
2755 ("cannot take address of bit-field %qD", TREE_OPERAND (x
, 1));
2759 /* ... fall through ... */
2765 x
= TREE_OPERAND (x
, 0);
2768 case COMPOUND_LITERAL_EXPR
:
2770 TREE_ADDRESSABLE (x
) = 1;
2777 if (C_DECL_REGISTER (x
)
2778 && DECL_NONLOCAL (x
))
2780 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
2783 ("global register variable %qD used in nested function", x
);
2786 pedwarn ("register variable %qD used in nested function", x
);
2788 else if (C_DECL_REGISTER (x
))
2790 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
2791 error ("address of global register variable %qD requested", x
);
2793 error ("address of register variable %qD requested", x
);
2799 TREE_ADDRESSABLE (x
) = 1;
2806 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
2809 build_conditional_expr (tree ifexp
, tree op1
, tree op2
)
2813 enum tree_code code1
;
2814 enum tree_code code2
;
2815 tree result_type
= NULL
;
2816 tree orig_op1
= op1
, orig_op2
= op2
;
2818 ifexp
= lang_hooks
.truthvalue_conversion (default_conversion (ifexp
));
2820 /* Promote both alternatives. */
2822 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
2823 op1
= default_conversion (op1
);
2824 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
2825 op2
= default_conversion (op2
);
2827 if (TREE_CODE (ifexp
) == ERROR_MARK
2828 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
2829 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
2830 return error_mark_node
;
2832 type1
= TREE_TYPE (op1
);
2833 code1
= TREE_CODE (type1
);
2834 type2
= TREE_TYPE (op2
);
2835 code2
= TREE_CODE (type2
);
2837 /* C90 does not permit non-lvalue arrays in conditional expressions.
2838 In C99 they will be pointers by now. */
2839 if (code1
== ARRAY_TYPE
|| code2
== ARRAY_TYPE
)
2841 error ("non-lvalue array in conditional expression");
2842 return error_mark_node
;
2845 /* Quickly detect the usual case where op1 and op2 have the same type
2847 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
2850 result_type
= type1
;
2852 result_type
= TYPE_MAIN_VARIANT (type1
);
2854 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
2855 || code1
== COMPLEX_TYPE
)
2856 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
2857 || code2
== COMPLEX_TYPE
))
2859 result_type
= common_type (type1
, type2
);
2861 /* If -Wsign-compare, warn here if type1 and type2 have
2862 different signedness. We'll promote the signed to unsigned
2863 and later code won't know it used to be different.
2864 Do this check on the original types, so that explicit casts
2865 will be considered, but default promotions won't. */
2866 if (warn_sign_compare
&& !skip_evaluation
)
2868 int unsigned_op1
= TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
2869 int unsigned_op2
= TYPE_UNSIGNED (TREE_TYPE (orig_op2
));
2871 if (unsigned_op1
^ unsigned_op2
)
2873 /* Do not warn if the result type is signed, since the
2874 signed type will only be chosen if it can represent
2875 all the values of the unsigned type. */
2876 if (!TYPE_UNSIGNED (result_type
))
2878 /* Do not warn if the signed quantity is an unsuffixed
2879 integer literal (or some static constant expression
2880 involving such literals) and it is non-negative. */
2881 else if ((unsigned_op2
&& tree_expr_nonnegative_p (op1
))
2882 || (unsigned_op1
&& tree_expr_nonnegative_p (op2
)))
2885 warning ("signed and unsigned type in conditional expression");
2889 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
2891 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
2892 pedwarn ("ISO C forbids conditional expr with only one void side");
2893 result_type
= void_type_node
;
2895 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
2897 if (comp_target_types (type1
, type2
, 1))
2898 result_type
= common_pointer_type (type1
, type2
);
2899 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
2900 && TREE_CODE (orig_op1
) != NOP_EXPR
)
2901 result_type
= qualify_type (type2
, type1
);
2902 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
2903 && TREE_CODE (orig_op2
) != NOP_EXPR
)
2904 result_type
= qualify_type (type1
, type2
);
2905 else if (VOID_TYPE_P (TREE_TYPE (type1
)))
2907 if (pedantic
&& TREE_CODE (TREE_TYPE (type2
)) == FUNCTION_TYPE
)
2908 pedwarn ("ISO C forbids conditional expr between "
2909 "%<void *%> and function pointer");
2910 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type1
),
2911 TREE_TYPE (type2
)));
2913 else if (VOID_TYPE_P (TREE_TYPE (type2
)))
2915 if (pedantic
&& TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
2916 pedwarn ("ISO C forbids conditional expr between "
2917 "%<void *%> and function pointer");
2918 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
2919 TREE_TYPE (type1
)));
2923 pedwarn ("pointer type mismatch in conditional expression");
2924 result_type
= build_pointer_type (void_type_node
);
2927 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
2929 if (!integer_zerop (op2
))
2930 pedwarn ("pointer/integer type mismatch in conditional expression");
2933 op2
= null_pointer_node
;
2935 result_type
= type1
;
2937 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2939 if (!integer_zerop (op1
))
2940 pedwarn ("pointer/integer type mismatch in conditional expression");
2943 op1
= null_pointer_node
;
2945 result_type
= type2
;
2950 if (flag_cond_mismatch
)
2951 result_type
= void_type_node
;
2954 error ("type mismatch in conditional expression");
2955 return error_mark_node
;
2959 /* Merge const and volatile flags of the incoming types. */
2961 = build_type_variant (result_type
,
2962 TREE_READONLY (op1
) || TREE_READONLY (op2
),
2963 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
2965 if (result_type
!= TREE_TYPE (op1
))
2966 op1
= convert_and_check (result_type
, op1
);
2967 if (result_type
!= TREE_TYPE (op2
))
2968 op2
= convert_and_check (result_type
, op2
);
2970 if (TREE_CODE (ifexp
) == INTEGER_CST
)
2971 return non_lvalue (integer_zerop (ifexp
) ? op2
: op1
);
2973 return fold (build3 (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
2976 /* Return a compound expression that performs two expressions and
2977 returns the value of the second of them. */
2980 build_compound_expr (tree expr1
, tree expr2
)
2982 /* Convert arrays and functions to pointers. */
2983 expr2
= default_function_array_conversion (expr2
);
2985 if (!TREE_SIDE_EFFECTS (expr1
))
2987 /* The left-hand operand of a comma expression is like an expression
2988 statement: with -Wextra or -Wunused, we should warn if it doesn't have
2989 any side-effects, unless it was explicitly cast to (void). */
2990 if (warn_unused_value
2991 && !(TREE_CODE (expr1
) == CONVERT_EXPR
2992 && VOID_TYPE_P (TREE_TYPE (expr1
))))
2993 warning ("left-hand operand of comma expression has no effect");
2996 /* With -Wunused, we should also warn if the left-hand operand does have
2997 side-effects, but computes a value which is not used. For example, in
2998 `foo() + bar(), baz()' the result of the `+' operator is not used,
2999 so we should issue a warning. */
3000 else if (warn_unused_value
)
3001 warn_if_unused_value (expr1
, input_location
);
3003 return build2 (COMPOUND_EXPR
, TREE_TYPE (expr2
), expr1
, expr2
);
3006 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3009 build_c_cast (tree type
, tree expr
)
3013 if (type
== error_mark_node
|| expr
== error_mark_node
)
3014 return error_mark_node
;
3016 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3017 only in <protocol> qualifications. But when constructing cast expressions,
3018 the protocols do matter and must be kept around. */
3019 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
3020 return build1 (NOP_EXPR
, type
, expr
);
3022 type
= TYPE_MAIN_VARIANT (type
);
3024 if (TREE_CODE (type
) == ARRAY_TYPE
)
3026 error ("cast specifies array type");
3027 return error_mark_node
;
3030 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3032 error ("cast specifies function type");
3033 return error_mark_node
;
3036 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
3040 if (TREE_CODE (type
) == RECORD_TYPE
3041 || TREE_CODE (type
) == UNION_TYPE
)
3042 pedwarn ("ISO C forbids casting nonscalar to the same type");
3045 else if (TREE_CODE (type
) == UNION_TYPE
)
3048 value
= default_function_array_conversion (value
);
3050 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3051 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
3052 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
3060 pedwarn ("ISO C forbids casts to union type");
3061 t
= digest_init (type
,
3062 build_constructor (type
,
3063 build_tree_list (field
, value
)),
3065 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
3066 TREE_INVARIANT (t
) = TREE_INVARIANT (value
);
3069 error ("cast to union type from type not present in union");
3070 return error_mark_node
;
3076 /* If casting to void, avoid the error that would come
3077 from default_conversion in the case of a non-lvalue array. */
3078 if (type
== void_type_node
)
3079 return build1 (CONVERT_EXPR
, type
, value
);
3081 /* Convert functions and arrays to pointers,
3082 but don't convert any other types. */
3083 value
= default_function_array_conversion (value
);
3084 otype
= TREE_TYPE (value
);
3086 /* Optionally warn about potentially worrisome casts. */
3089 && TREE_CODE (type
) == POINTER_TYPE
3090 && TREE_CODE (otype
) == POINTER_TYPE
)
3092 tree in_type
= type
;
3093 tree in_otype
= otype
;
3097 /* Check that the qualifiers on IN_TYPE are a superset of
3098 the qualifiers of IN_OTYPE. The outermost level of
3099 POINTER_TYPE nodes is uninteresting and we stop as soon
3100 as we hit a non-POINTER_TYPE node on either type. */
3103 in_otype
= TREE_TYPE (in_otype
);
3104 in_type
= TREE_TYPE (in_type
);
3106 /* GNU C allows cv-qualified function types. 'const'
3107 means the function is very pure, 'volatile' means it
3108 can't return. We need to warn when such qualifiers
3109 are added, not when they're taken away. */
3110 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
3111 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
3112 added
|= (TYPE_QUALS (in_type
) & ~TYPE_QUALS (in_otype
));
3114 discarded
|= (TYPE_QUALS (in_otype
) & ~TYPE_QUALS (in_type
));
3116 while (TREE_CODE (in_type
) == POINTER_TYPE
3117 && TREE_CODE (in_otype
) == POINTER_TYPE
);
3120 warning ("cast adds new qualifiers to function type");
3123 /* There are qualifiers present in IN_OTYPE that are not
3124 present in IN_TYPE. */
3125 warning ("cast discards qualifiers from pointer target type");
3128 /* Warn about possible alignment problems. */
3129 if (STRICT_ALIGNMENT
&& warn_cast_align
3130 && TREE_CODE (type
) == POINTER_TYPE
3131 && TREE_CODE (otype
) == POINTER_TYPE
3132 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
3133 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3134 /* Don't warn about opaque types, where the actual alignment
3135 restriction is unknown. */
3136 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
3137 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
3138 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
3139 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
3140 warning ("cast increases required alignment of target type");
3142 if (TREE_CODE (type
) == INTEGER_TYPE
3143 && TREE_CODE (otype
) == POINTER_TYPE
3144 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3145 && !TREE_CONSTANT (value
))
3146 warning ("cast from pointer to integer of different size");
3148 if (warn_bad_function_cast
3149 && TREE_CODE (value
) == CALL_EXPR
3150 && TREE_CODE (type
) != TREE_CODE (otype
))
3151 warning ("cast from function call of type %qT to non-matching "
3152 "type %qT", otype
, type
);
3154 if (TREE_CODE (type
) == POINTER_TYPE
3155 && TREE_CODE (otype
) == INTEGER_TYPE
3156 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3157 /* Don't warn about converting any constant. */
3158 && !TREE_CONSTANT (value
))
3159 warning ("cast to pointer from integer of different size");
3161 if (TREE_CODE (type
) == POINTER_TYPE
3162 && TREE_CODE (otype
) == POINTER_TYPE
3163 && TREE_CODE (expr
) == ADDR_EXPR
3164 && DECL_P (TREE_OPERAND (expr
, 0))
3165 && flag_strict_aliasing
&& warn_strict_aliasing
3166 && !VOID_TYPE_P (TREE_TYPE (type
)))
3168 /* Casting the address of a decl to non void pointer. Warn
3169 if the cast breaks type based aliasing. */
3170 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)))
3171 warning ("type-punning to incomplete type might break strict-aliasing rules");
3174 HOST_WIDE_INT set1
= get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
3175 HOST_WIDE_INT set2
= get_alias_set (TREE_TYPE (type
));
3177 if (!alias_sets_conflict_p (set1
, set2
))
3178 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3179 else if (warn_strict_aliasing
> 1
3180 && !alias_sets_might_conflict_p (set1
, set2
))
3181 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3185 /* If pedantic, warn for conversions between function and object
3186 pointer types, except for converting a null pointer constant
3187 to function pointer type. */
3189 && TREE_CODE (type
) == POINTER_TYPE
3190 && TREE_CODE (otype
) == POINTER_TYPE
3191 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
3192 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
3193 pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3196 && TREE_CODE (type
) == POINTER_TYPE
3197 && TREE_CODE (otype
) == POINTER_TYPE
3198 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
3199 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3200 && !(integer_zerop (value
) && TREE_TYPE (otype
) == void_type_node
3201 && TREE_CODE (expr
) != NOP_EXPR
))
3202 pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3205 /* Replace a nonvolatile const static variable with its value. */
3206 if (optimize
&& TREE_CODE (value
) == VAR_DECL
)
3207 value
= decl_constant_value (value
);
3208 value
= convert (type
, value
);
3210 /* Ignore any integer overflow caused by the cast. */
3211 if (TREE_CODE (value
) == INTEGER_CST
)
3213 if (EXPR_P (ovalue
))
3214 /* If OVALUE had overflow set, then so will VALUE, so it
3215 is safe to overwrite. */
3216 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
3218 TREE_OVERFLOW (value
) = 0;
3220 if (CONSTANT_CLASS_P (ovalue
))
3221 /* Similarly, constant_overflow cannot have become
3223 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
3227 /* Don't let a cast be an lvalue. */
3229 value
= non_lvalue (value
);
3234 /* Interpret a cast of expression EXPR to type TYPE. */
3236 c_cast_expr (struct c_type_name
*type_name
, tree expr
)
3239 int saved_wsp
= warn_strict_prototypes
;
3241 /* This avoids warnings about unprototyped casts on
3242 integers. E.g. "#define SIG_DFL (void(*)())0". */
3243 if (TREE_CODE (expr
) == INTEGER_CST
)
3244 warn_strict_prototypes
= 0;
3245 type
= groktypename (type_name
);
3246 warn_strict_prototypes
= saved_wsp
;
3248 return build_c_cast (type
, expr
);
3252 /* Build an assignment expression of lvalue LHS from value RHS.
3253 MODIFYCODE is the code for a binary operator that we use
3254 to combine the old value of LHS with RHS to get the new value.
3255 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3258 build_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
)
3262 tree lhstype
= TREE_TYPE (lhs
);
3263 tree olhstype
= lhstype
;
3265 /* Types that aren't fully specified cannot be used in assignments. */
3266 lhs
= require_complete_type (lhs
);
3268 /* Avoid duplicate error messages from operands that had errors. */
3269 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
3270 return error_mark_node
;
3272 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3273 /* Do not use STRIP_NOPS here. We do not want an enumerator
3274 whose value is 0 to count as a null pointer constant. */
3275 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3276 rhs
= TREE_OPERAND (rhs
, 0);
3280 /* If a binary op has been requested, combine the old LHS value with the RHS
3281 producing the value we should actually store into the LHS. */
3283 if (modifycode
!= NOP_EXPR
)
3285 lhs
= stabilize_reference (lhs
);
3286 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
3289 if (!lvalue_or_else (lhs
, lv_assign
))
3290 return error_mark_node
;
3292 /* Give an error for storing in something that is 'const'. */
3294 if (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
3295 || ((TREE_CODE (lhstype
) == RECORD_TYPE
3296 || TREE_CODE (lhstype
) == UNION_TYPE
)
3297 && C_TYPE_FIELDS_READONLY (lhstype
)))
3298 readonly_error (lhs
, lv_assign
);
3300 /* If storing into a structure or union member,
3301 it has probably been given type `int'.
3302 Compute the type that would go with
3303 the actual amount of storage the member occupies. */
3305 if (TREE_CODE (lhs
) == COMPONENT_REF
3306 && (TREE_CODE (lhstype
) == INTEGER_TYPE
3307 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
3308 || TREE_CODE (lhstype
) == REAL_TYPE
3309 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
3310 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
3312 /* If storing in a field that is in actuality a short or narrower than one,
3313 we must store in the field in its actual type. */
3315 if (lhstype
!= TREE_TYPE (lhs
))
3317 lhs
= copy_node (lhs
);
3318 TREE_TYPE (lhs
) = lhstype
;
3321 /* Convert new value to destination type. */
3323 newrhs
= convert_for_assignment (lhstype
, newrhs
, ic_assign
,
3324 NULL_TREE
, NULL_TREE
, 0);
3325 if (TREE_CODE (newrhs
) == ERROR_MARK
)
3326 return error_mark_node
;
3328 /* Scan operands. */
3330 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
3331 TREE_SIDE_EFFECTS (result
) = 1;
3333 /* If we got the LHS in a different type for storing in,
3334 convert the result back to the nominal type of LHS
3335 so that the value we return always has the same type
3336 as the LHS argument. */
3338 if (olhstype
== TREE_TYPE (result
))
3340 return convert_for_assignment (olhstype
, result
, ic_assign
,
3341 NULL_TREE
, NULL_TREE
, 0);
3344 /* Convert value RHS to type TYPE as preparation for an assignment
3345 to an lvalue of type TYPE.
3346 The real work of conversion is done by `convert'.
3347 The purpose of this function is to generate error messages
3348 for assignments that are not allowed in C.
3349 ERRTYPE says whether it is argument passing, assignment,
3350 initialization or return.
3352 FUNCTION is a tree for the function being called.
3353 PARMNUM is the number of the argument, for printing in error messages. */
3356 convert_for_assignment (tree type
, tree rhs
, enum impl_conv errtype
,
3357 tree fundecl
, tree function
, int parmnum
)
3359 enum tree_code codel
= TREE_CODE (type
);
3361 enum tree_code coder
;
3362 tree rname
= NULL_TREE
;
3364 if (errtype
== ic_argpass
|| errtype
== ic_argpass_nonproto
)
3367 /* Change pointer to function to the function itself for
3369 if (TREE_CODE (function
) == ADDR_EXPR
3370 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
3371 function
= TREE_OPERAND (function
, 0);
3373 /* Handle an ObjC selector specially for diagnostics. */
3374 selector
= objc_message_selector ();
3376 if (selector
&& parmnum
> 2)
3383 /* This macro is used to emit diagnostics to ensure that all format
3384 strings are complete sentences, visible to gettext and checked at
3386 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \
3391 pedwarn (AR, parmnum, rname); \
3393 case ic_argpass_nonproto: \
3394 warning (AR, parmnum, rname); \
3406 gcc_unreachable (); \
3410 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3411 /* Do not use STRIP_NOPS here. We do not want an enumerator
3412 whose value is 0 to count as a null pointer constant. */
3413 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3414 rhs
= TREE_OPERAND (rhs
, 0);
3416 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
3417 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
)
3418 rhs
= default_conversion (rhs
);
3419 else if (optimize
&& TREE_CODE (rhs
) == VAR_DECL
)
3420 rhs
= decl_constant_value_for_broken_optimization (rhs
);
3422 rhstype
= TREE_TYPE (rhs
);
3423 coder
= TREE_CODE (rhstype
);
3425 if (coder
== ERROR_MARK
)
3426 return error_mark_node
;
3428 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
3430 overflow_warning (rhs
);
3431 /* Check for Objective-C protocols. This will automatically
3432 issue a warning if there are protocol violations. No need to
3433 use the return value. */
3434 if (c_dialect_objc ())
3435 objc_comptypes (type
, rhstype
, 0);
3439 if (coder
== VOID_TYPE
)
3441 /* Except for passing an argument to an unprototyped function,
3442 this is a constraint violation. When passing an argument to
3443 an unprototyped function, it is compile-time undefined;
3444 making it a constraint in that case was rejected in
3446 error ("void value not ignored as it ought to be");
3447 return error_mark_node
;
3449 /* A type converts to a reference to it.
3450 This code doesn't fully support references, it's just for the
3451 special case of va_start and va_copy. */
3452 if (codel
== REFERENCE_TYPE
3453 && comptypes (TREE_TYPE (type
), TREE_TYPE (rhs
)) == 1)
3455 if (!lvalue_p (rhs
))
3457 error ("cannot pass rvalue to reference parameter");
3458 return error_mark_node
;
3460 if (!c_mark_addressable (rhs
))
3461 return error_mark_node
;
3462 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
3464 /* We already know that these two types are compatible, but they
3465 may not be exactly identical. In fact, `TREE_TYPE (type)' is
3466 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3467 likely to be va_list, a typedef to __builtin_va_list, which
3468 is different enough that it will cause problems later. */
3469 if (TREE_TYPE (TREE_TYPE (rhs
)) != TREE_TYPE (type
))
3470 rhs
= build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), rhs
);
3472 rhs
= build1 (NOP_EXPR
, type
, rhs
);
3475 /* Some types can interconvert without explicit casts. */
3476 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
3477 && vector_types_convertible_p (type
, TREE_TYPE (rhs
)))
3478 return convert (type
, rhs
);
3479 /* Arithmetic types all interconvert, and enum is treated like int. */
3480 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
3481 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
3482 || codel
== BOOLEAN_TYPE
)
3483 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
3484 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
3485 || coder
== BOOLEAN_TYPE
))
3486 return convert_and_check (type
, rhs
);
3488 /* Conversion to a transparent union from its member types.
3489 This applies only to function arguments. */
3490 else if (codel
== UNION_TYPE
&& TYPE_TRANSPARENT_UNION (type
)
3491 && (errtype
== ic_argpass
|| errtype
== ic_argpass_nonproto
))
3494 tree marginal_memb_type
= 0;
3496 for (memb_types
= TYPE_FIELDS (type
); memb_types
;
3497 memb_types
= TREE_CHAIN (memb_types
))
3499 tree memb_type
= TREE_TYPE (memb_types
);
3501 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
3502 TYPE_MAIN_VARIANT (rhstype
)))
3505 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
3508 if (coder
== POINTER_TYPE
)
3510 tree ttl
= TREE_TYPE (memb_type
);
3511 tree ttr
= TREE_TYPE (rhstype
);
3513 /* Any non-function converts to a [const][volatile] void *
3514 and vice versa; otherwise, targets must be the same.
3515 Meanwhile, the lhs target must have all the qualifiers of
3517 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3518 || comp_target_types (memb_type
, rhstype
, 0))
3520 /* If this type won't generate any warnings, use it. */
3521 if (TYPE_QUALS (ttl
) == TYPE_QUALS (ttr
)
3522 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
3523 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
3524 ? ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
3525 == TYPE_QUALS (ttr
))
3526 : ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
3527 == TYPE_QUALS (ttl
))))
3530 /* Keep looking for a better type, but remember this one. */
3531 if (!marginal_memb_type
)
3532 marginal_memb_type
= memb_type
;
3536 /* Can convert integer zero to any pointer type. */
3537 if (integer_zerop (rhs
)
3538 || (TREE_CODE (rhs
) == NOP_EXPR
3539 && integer_zerop (TREE_OPERAND (rhs
, 0))))
3541 rhs
= null_pointer_node
;
3546 if (memb_types
|| marginal_memb_type
)
3550 /* We have only a marginally acceptable member type;
3551 it needs a warning. */
3552 tree ttl
= TREE_TYPE (marginal_memb_type
);
3553 tree ttr
= TREE_TYPE (rhstype
);
3555 /* Const and volatile mean something different for function
3556 types, so the usual warnings are not appropriate. */
3557 if (TREE_CODE (ttr
) == FUNCTION_TYPE
3558 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
3560 /* Because const and volatile on functions are
3561 restrictions that say the function will not do
3562 certain things, it is okay to use a const or volatile
3563 function where an ordinary one is wanted, but not
3565 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
3566 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE "
3567 "makes qualified function "
3568 "pointer from unqualified"),
3569 N_("assignment makes qualified "
3570 "function pointer from "
3572 N_("initialization makes qualified "
3573 "function pointer from "
3575 N_("return makes qualified function "
3576 "pointer from unqualified"));
3578 else if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
3579 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3580 "qualifiers from pointer target type"),
3581 N_("assignment discards qualifiers "
3582 "from pointer target type"),
3583 N_("initialization discards qualifiers "
3584 "from pointer target type"),
3585 N_("return discards qualifiers from "
3586 "pointer target type"));
3589 if (pedantic
&& !DECL_IN_SYSTEM_HEADER (fundecl
))
3590 pedwarn ("ISO C prohibits argument conversion to union type");
3592 return build1 (NOP_EXPR
, type
, rhs
);
3596 /* Conversions among pointers */
3597 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
3598 && (coder
== codel
))
3600 tree ttl
= TREE_TYPE (type
);
3601 tree ttr
= TREE_TYPE (rhstype
);
3602 bool is_opaque_pointer
;
3603 int target_cmp
= 0; /* Cache comp_target_types () result. */
3605 /* Opaque pointers are treated like void pointers. */
3606 is_opaque_pointer
= (targetm
.vector_opaque_p (type
)
3607 || targetm
.vector_opaque_p (rhstype
))
3608 && TREE_CODE (ttl
) == VECTOR_TYPE
3609 && TREE_CODE (ttr
) == VECTOR_TYPE
;
3611 /* Any non-function converts to a [const][volatile] void *
3612 and vice versa; otherwise, targets must be the same.
3613 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
3614 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3615 || (target_cmp
= comp_target_types (type
, rhstype
, 0))
3616 || is_opaque_pointer
3617 || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl
))
3618 == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
3621 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
3624 /* Check TREE_CODE to catch cases like (void *) (char *) 0
3625 which are not ANSI null ptr constants. */
3626 && (!integer_zerop (rhs
) || TREE_CODE (rhs
) == NOP_EXPR
)
3627 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
3628 WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of "
3629 "%qE between function pointer "
3631 N_("ISO C forbids assignment between "
3632 "function pointer and %<void *%>"),
3633 N_("ISO C forbids initialization between "
3634 "function pointer and %<void *%>"),
3635 N_("ISO C forbids return between function "
3636 "pointer and %<void *%>"));
3637 /* Const and volatile mean something different for function types,
3638 so the usual warnings are not appropriate. */
3639 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
3640 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
3642 if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
3643 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3644 "qualifiers from pointer target type"),
3645 N_("assignment discards qualifiers "
3646 "from pointer target type"),
3647 N_("initialization discards qualifiers "
3648 "from pointer target type"),
3649 N_("return discards qualifiers from "
3650 "pointer target type"));
3651 /* If this is not a case of ignoring a mismatch in signedness,
3653 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3656 /* If there is a mismatch, do warn. */
3658 WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument "
3659 "%d of %qE differ in signedness"),
3660 N_("pointer targets in assignment "
3661 "differ in signedness"),
3662 N_("pointer targets in initialization "
3663 "differ in signedness"),
3664 N_("pointer targets in return differ "
3667 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
3668 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
3670 /* Because const and volatile on functions are restrictions
3671 that say the function will not do certain things,
3672 it is okay to use a const or volatile function
3673 where an ordinary one is wanted, but not vice-versa. */
3674 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
3675 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3676 "qualified function pointer "
3677 "from unqualified"),
3678 N_("assignment makes qualified function "
3679 "pointer from unqualified"),
3680 N_("initialization makes qualified "
3681 "function pointer from unqualified"),
3682 N_("return makes qualified function "
3683 "pointer from unqualified"));
3687 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from "
3688 "incompatible pointer type"),
3689 N_("assignment from incompatible pointer type"),
3690 N_("initialization from incompatible "
3692 N_("return from incompatible pointer type"));
3693 return convert (type
, rhs
);
3695 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
3697 /* ??? This should not be an error when inlining calls to
3698 unprototyped functions. */
3699 error ("invalid use of non-lvalue array");
3700 return error_mark_node
;
3702 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
3704 /* An explicit constant 0 can convert to a pointer,
3705 or one that results from arithmetic, even including
3706 a cast to integer type. */
3707 if (!(TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
))
3709 !(TREE_CODE (rhs
) == NOP_EXPR
3710 && TREE_CODE (TREE_TYPE (rhs
)) == INTEGER_TYPE
3711 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == INTEGER_CST
3712 && integer_zerop (TREE_OPERAND (rhs
, 0))))
3713 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3714 "pointer from integer without a cast"),
3715 N_("assignment makes pointer from integer "
3717 N_("initialization makes pointer from "
3718 "integer without a cast"),
3719 N_("return makes pointer from integer "
3722 return convert (type
, rhs
);
3724 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
3726 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer "
3727 "from pointer without a cast"),
3728 N_("assignment makes integer from pointer "
3730 N_("initialization makes integer from pointer "
3732 N_("return makes integer from pointer "
3734 return convert (type
, rhs
);
3736 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
3737 return convert (type
, rhs
);
3742 case ic_argpass_nonproto
:
3743 /* ??? This should not be an error when inlining calls to
3744 unprototyped functions. */
3745 error ("incompatible type for argument %d of %qE", parmnum
, rname
);
3748 error ("incompatible types in assignment");
3751 error ("incompatible types in initialization");
3754 error ("incompatible types in return");
3760 return error_mark_node
;
3763 /* Convert VALUE for assignment into inlined parameter PARM. ARGNUM
3764 is used for error and waring reporting and indicates which argument
3765 is being processed. */
3768 c_convert_parm_for_inlining (tree parm
, tree value
, tree fn
, int argnum
)
3772 /* If FN was prototyped, the value has been converted already
3773 in convert_arguments. */
3774 if (!value
|| TYPE_ARG_TYPES (TREE_TYPE (fn
)))
3777 type
= TREE_TYPE (parm
);
3778 ret
= convert_for_assignment (type
, value
,
3779 ic_argpass_nonproto
, fn
,
3781 if (targetm
.calls
.promote_prototypes (TREE_TYPE (fn
))
3782 && INTEGRAL_TYPE_P (type
)
3783 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
3784 ret
= default_conversion (ret
);
3788 /* If VALUE is a compound expr all of whose expressions are constant, then
3789 return its value. Otherwise, return error_mark_node.
3791 This is for handling COMPOUND_EXPRs as initializer elements
3792 which is allowed with a warning when -pedantic is specified. */
3795 valid_compound_expr_initializer (tree value
, tree endtype
)
3797 if (TREE_CODE (value
) == COMPOUND_EXPR
)
3799 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
3801 return error_mark_node
;
3802 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
3805 else if (!initializer_constant_valid_p (value
, endtype
))
3806 return error_mark_node
;
3811 /* Perform appropriate conversions on the initial value of a variable,
3812 store it in the declaration DECL,
3813 and print any error messages that are appropriate.
3814 If the init is invalid, store an ERROR_MARK. */
3817 store_init_value (tree decl
, tree init
)
3821 /* If variable's type was invalidly declared, just ignore it. */
3823 type
= TREE_TYPE (decl
);
3824 if (TREE_CODE (type
) == ERROR_MARK
)
3827 /* Digest the specified initializer into an expression. */
3829 value
= digest_init (type
, init
, true, TREE_STATIC (decl
));
3831 /* Store the expression if valid; else report error. */
3833 if (warn_traditional
&& !in_system_header
3834 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
3835 warning ("traditional C rejects automatic aggregate initialization");
3837 DECL_INITIAL (decl
) = value
;
3839 /* ANSI wants warnings about out-of-range constant initializers. */
3840 STRIP_TYPE_NOPS (value
);
3841 constant_expression_warning (value
);
3843 /* Check if we need to set array size from compound literal size. */
3844 if (TREE_CODE (type
) == ARRAY_TYPE
3845 && TYPE_DOMAIN (type
) == 0
3846 && value
!= error_mark_node
)
3848 tree inside_init
= init
;
3850 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
3851 inside_init
= TREE_OPERAND (init
, 0);
3852 inside_init
= fold (inside_init
);
3854 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
3856 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
3858 if (TYPE_DOMAIN (TREE_TYPE (decl
)))
3860 /* For int foo[] = (int [3]){1}; we need to set array size
3861 now since later on array initializer will be just the
3862 brace enclosed list of the compound literal. */
3863 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (decl
));
3865 layout_decl (decl
, 0);
3871 /* Methods for storing and printing names for error messages. */
3873 /* Implement a spelling stack that allows components of a name to be pushed
3874 and popped. Each element on the stack is this structure. */
3886 #define SPELLING_STRING 1
3887 #define SPELLING_MEMBER 2
3888 #define SPELLING_BOUNDS 3
3890 static struct spelling
*spelling
; /* Next stack element (unused). */
3891 static struct spelling
*spelling_base
; /* Spelling stack base. */
3892 static int spelling_size
; /* Size of the spelling stack. */
3894 /* Macros to save and restore the spelling stack around push_... functions.
3895 Alternative to SAVE_SPELLING_STACK. */
3897 #define SPELLING_DEPTH() (spelling - spelling_base)
3898 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3900 /* Push an element on the spelling stack with type KIND and assign VALUE
3903 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
3905 int depth = SPELLING_DEPTH (); \
3907 if (depth >= spelling_size) \
3909 spelling_size += 10; \
3910 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
3912 RESTORE_SPELLING_DEPTH (depth); \
3915 spelling->kind = (KIND); \
3916 spelling->MEMBER = (VALUE); \
3920 /* Push STRING on the stack. Printed literally. */
3923 push_string (const char *string
)
3925 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
3928 /* Push a member name on the stack. Printed as '.' STRING. */
3931 push_member_name (tree decl
)
3933 const char *const string
3934 = DECL_NAME (decl
) ? IDENTIFIER_POINTER (DECL_NAME (decl
)) : "<anonymous>";
3935 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
3938 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
3941 push_array_bounds (int bounds
)
3943 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
3946 /* Compute the maximum size in bytes of the printed spelling. */
3949 spelling_length (void)
3954 for (p
= spelling_base
; p
< spelling
; p
++)
3956 if (p
->kind
== SPELLING_BOUNDS
)
3959 size
+= strlen (p
->u
.s
) + 1;
3965 /* Print the spelling to BUFFER and return it. */
3968 print_spelling (char *buffer
)
3973 for (p
= spelling_base
; p
< spelling
; p
++)
3974 if (p
->kind
== SPELLING_BOUNDS
)
3976 sprintf (d
, "[%d]", p
->u
.i
);
3982 if (p
->kind
== SPELLING_MEMBER
)
3984 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
3991 /* Issue an error message for a bad initializer component.
3992 MSGID identifies the message.
3993 The component name is taken from the spelling stack. */
3996 error_init (const char *msgid
)
4000 error ("%s", _(msgid
));
4001 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4003 error ("(near initialization for %qs)", ofwhat
);
4006 /* Issue a pedantic warning for a bad initializer component.
4007 MSGID identifies the message.
4008 The component name is taken from the spelling stack. */
4011 pedwarn_init (const char *msgid
)
4015 pedwarn ("%s", _(msgid
));
4016 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4018 pedwarn ("(near initialization for %qs)", ofwhat
);
4021 /* Issue a warning for a bad initializer component.
4022 MSGID identifies the message.
4023 The component name is taken from the spelling stack. */
4026 warning_init (const char *msgid
)
4030 warning ("%s", _(msgid
));
4031 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4033 warning ("(near initialization for %qs)", ofwhat
);
4036 /* If TYPE is an array type and EXPR is a parenthesized string
4037 constant, warn if pedantic that EXPR is being used to initialize an
4038 object of type TYPE. */
4041 maybe_warn_string_init (tree type
, struct c_expr expr
)
4044 && TREE_CODE (type
) == ARRAY_TYPE
4045 && TREE_CODE (expr
.value
) == STRING_CST
4046 && expr
.original_code
!= STRING_CST
)
4047 pedwarn_init ("array initialized from parenthesized string constant");
4050 /* Digest the parser output INIT as an initializer for type TYPE.
4051 Return a C expression of type TYPE to represent the initial value.
4053 If INIT is a string constant, STRICT_STRING is true if it is
4054 unparenthesized or we should not warn here for it being parenthesized.
4055 For other types of INIT, STRICT_STRING is not used.
4057 REQUIRE_CONSTANT requests an error if non-constant initializers or
4058 elements are seen. */
4061 digest_init (tree type
, tree init
, bool strict_string
, int require_constant
)
4063 enum tree_code code
= TREE_CODE (type
);
4064 tree inside_init
= init
;
4066 if (type
== error_mark_node
4067 || init
== error_mark_node
4068 || TREE_TYPE (init
) == error_mark_node
)
4069 return error_mark_node
;
4071 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4072 /* Do not use STRIP_NOPS here. We do not want an enumerator
4073 whose value is 0 to count as a null pointer constant. */
4074 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
4075 inside_init
= TREE_OPERAND (init
, 0);
4077 inside_init
= fold (inside_init
);
4079 /* Initialization of an array of chars from a string constant
4080 optionally enclosed in braces. */
4082 if (code
== ARRAY_TYPE
&& inside_init
4083 && TREE_CODE (inside_init
) == STRING_CST
)
4085 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4086 /* Note that an array could be both an array of character type
4087 and an array of wchar_t if wchar_t is signed char or unsigned
4089 bool char_array
= (typ1
== char_type_node
4090 || typ1
== signed_char_type_node
4091 || typ1
== unsigned_char_type_node
);
4092 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
4093 if (char_array
|| wchar_array
)
4097 expr
.value
= inside_init
;
4098 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
4099 maybe_warn_string_init (type
, expr
);
4102 = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)))
4105 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4106 TYPE_MAIN_VARIANT (type
)))
4109 if (!wchar_array
&& !char_string
)
4111 error_init ("char-array initialized from wide string");
4112 return error_mark_node
;
4114 if (char_string
&& !char_array
)
4116 error_init ("wchar_t-array initialized from non-wide string");
4117 return error_mark_node
;
4120 TREE_TYPE (inside_init
) = type
;
4121 if (TYPE_DOMAIN (type
) != 0
4122 && TYPE_SIZE (type
) != 0
4123 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
4124 /* Subtract 1 (or sizeof (wchar_t))
4125 because it's ok to ignore the terminating null char
4126 that is counted in the length of the constant. */
4127 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
4128 TREE_STRING_LENGTH (inside_init
)
4129 - ((TYPE_PRECISION (typ1
)
4130 != TYPE_PRECISION (char_type_node
))
4131 ? (TYPE_PRECISION (wchar_type_node
)
4134 pedwarn_init ("initializer-string for array of chars is too long");
4138 else if (INTEGRAL_TYPE_P (typ1
))
4140 error_init ("array of inappropriate type initialized "
4141 "from string constant");
4142 return error_mark_node
;
4146 /* Build a VECTOR_CST from a *constant* vector constructor. If the
4147 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4148 below and handle as a constructor. */
4149 if (code
== VECTOR_TYPE
4150 && TREE_CODE (TREE_TYPE (inside_init
)) == VECTOR_TYPE
4151 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
)
4152 && TREE_CONSTANT (inside_init
))
4154 if (TREE_CODE (inside_init
) == VECTOR_CST
4155 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4156 TYPE_MAIN_VARIANT (type
)))
4159 return build_vector (type
, CONSTRUCTOR_ELTS (inside_init
));
4162 /* Any type can be initialized
4163 from an expression of the same type, optionally with braces. */
4165 if (inside_init
&& TREE_TYPE (inside_init
) != 0
4166 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4167 TYPE_MAIN_VARIANT (type
))
4168 || (code
== ARRAY_TYPE
4169 && comptypes (TREE_TYPE (inside_init
), type
))
4170 || (code
== VECTOR_TYPE
4171 && comptypes (TREE_TYPE (inside_init
), type
))
4172 || (code
== POINTER_TYPE
4173 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
4174 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
4176 || (code
== POINTER_TYPE
4177 && TREE_CODE (TREE_TYPE (inside_init
)) == FUNCTION_TYPE
4178 && comptypes (TREE_TYPE (inside_init
),
4179 TREE_TYPE (type
)))))
4181 if (code
== POINTER_TYPE
)
4183 inside_init
= default_function_array_conversion (inside_init
);
4185 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
4187 error_init ("invalid use of non-lvalue array");
4188 return error_mark_node
;
4192 if (code
== VECTOR_TYPE
)
4193 /* Although the types are compatible, we may require a
4195 inside_init
= convert (type
, inside_init
);
4197 if (require_constant
&& !flag_isoc99
4198 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
4200 /* As an extension, allow initializing objects with static storage
4201 duration with compound literals (which are then treated just as
4202 the brace enclosed list they contain). */
4203 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
4204 inside_init
= DECL_INITIAL (decl
);
4207 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
4208 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
4210 error_init ("array initialized from non-constant array expression");
4211 return error_mark_node
;
4214 if (optimize
&& TREE_CODE (inside_init
) == VAR_DECL
)
4215 inside_init
= decl_constant_value_for_broken_optimization (inside_init
);
4217 /* Compound expressions can only occur here if -pedantic or
4218 -pedantic-errors is specified. In the later case, we always want
4219 an error. In the former case, we simply want a warning. */
4220 if (require_constant
&& pedantic
4221 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
4224 = valid_compound_expr_initializer (inside_init
,
4225 TREE_TYPE (inside_init
));
4226 if (inside_init
== error_mark_node
)
4227 error_init ("initializer element is not constant");
4229 pedwarn_init ("initializer element is not constant");
4230 if (flag_pedantic_errors
)
4231 inside_init
= error_mark_node
;
4233 else if (require_constant
4234 && !initializer_constant_valid_p (inside_init
,
4235 TREE_TYPE (inside_init
)))
4237 error_init ("initializer element is not constant");
4238 inside_init
= error_mark_node
;
4244 /* Handle scalar types, including conversions. */
4246 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
4247 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
4248 || code
== VECTOR_TYPE
)
4250 /* Note that convert_for_assignment calls default_conversion
4251 for arrays and functions. We must not call it in the
4252 case where inside_init is a null pointer constant. */
4254 = convert_for_assignment (type
, init
, ic_init
,
4255 NULL_TREE
, NULL_TREE
, 0);
4257 /* Check to see if we have already given an error message. */
4258 if (inside_init
== error_mark_node
)
4260 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
4262 error_init ("initializer element is not constant");
4263 inside_init
= error_mark_node
;
4265 else if (require_constant
4266 && !initializer_constant_valid_p (inside_init
,
4267 TREE_TYPE (inside_init
)))
4269 error_init ("initializer element is not computable at load time");
4270 inside_init
= error_mark_node
;
4276 /* Come here only for records and arrays. */
4278 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4280 error_init ("variable-sized object may not be initialized");
4281 return error_mark_node
;
4284 error_init ("invalid initializer");
4285 return error_mark_node
;
4288 /* Handle initializers that use braces. */
4290 /* Type of object we are accumulating a constructor for.
4291 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4292 static tree constructor_type
;
4294 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4296 static tree constructor_fields
;
4298 /* For an ARRAY_TYPE, this is the specified index
4299 at which to store the next element we get. */
4300 static tree constructor_index
;
4302 /* For an ARRAY_TYPE, this is the maximum index. */
4303 static tree constructor_max_index
;
4305 /* For a RECORD_TYPE, this is the first field not yet written out. */
4306 static tree constructor_unfilled_fields
;
4308 /* For an ARRAY_TYPE, this is the index of the first element
4309 not yet written out. */
4310 static tree constructor_unfilled_index
;
4312 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4313 This is so we can generate gaps between fields, when appropriate. */
4314 static tree constructor_bit_index
;
4316 /* If we are saving up the elements rather than allocating them,
4317 this is the list of elements so far (in reverse order,
4318 most recent first). */
4319 static tree constructor_elements
;
4321 /* 1 if constructor should be incrementally stored into a constructor chain,
4322 0 if all the elements should be kept in AVL tree. */
4323 static int constructor_incremental
;
4325 /* 1 if so far this constructor's elements are all compile-time constants. */
4326 static int constructor_constant
;
4328 /* 1 if so far this constructor's elements are all valid address constants. */
4329 static int constructor_simple
;
4331 /* 1 if this constructor is erroneous so far. */
4332 static int constructor_erroneous
;
4334 /* Structure for managing pending initializer elements, organized as an
4339 struct init_node
*left
, *right
;
4340 struct init_node
*parent
;
4346 /* Tree of pending elements at this constructor level.
4347 These are elements encountered out of order
4348 which belong at places we haven't reached yet in actually
4350 Will never hold tree nodes across GC runs. */
4351 static struct init_node
*constructor_pending_elts
;
4353 /* The SPELLING_DEPTH of this constructor. */
4354 static int constructor_depth
;
4356 /* DECL node for which an initializer is being read.
4357 0 means we are reading a constructor expression
4358 such as (struct foo) {...}. */
4359 static tree constructor_decl
;
4361 /* Nonzero if this is an initializer for a top-level decl. */
4362 static int constructor_top_level
;
4364 /* Nonzero if there were any member designators in this initializer. */
4365 static int constructor_designated
;
4367 /* Nesting depth of designator list. */
4368 static int designator_depth
;
4370 /* Nonzero if there were diagnosed errors in this designator list. */
4371 static int designator_errorneous
;
4374 /* This stack has a level for each implicit or explicit level of
4375 structuring in the initializer, including the outermost one. It
4376 saves the values of most of the variables above. */
4378 struct constructor_range_stack
;
4380 struct constructor_stack
4382 struct constructor_stack
*next
;
4387 tree unfilled_index
;
4388 tree unfilled_fields
;
4391 struct init_node
*pending_elts
;
4394 /* If value nonzero, this value should replace the entire
4395 constructor at this level. */
4396 struct c_expr replacement_value
;
4397 struct constructor_range_stack
*range_stack
;
4407 struct constructor_stack
*constructor_stack
;
4409 /* This stack represents designators from some range designator up to
4410 the last designator in the list. */
4412 struct constructor_range_stack
4414 struct constructor_range_stack
*next
, *prev
;
4415 struct constructor_stack
*stack
;
4422 struct constructor_range_stack
*constructor_range_stack
;
4424 /* This stack records separate initializers that are nested.
4425 Nested initializers can't happen in ANSI C, but GNU C allows them
4426 in cases like { ... (struct foo) { ... } ... }. */
4428 struct initializer_stack
4430 struct initializer_stack
*next
;
4432 struct constructor_stack
*constructor_stack
;
4433 struct constructor_range_stack
*constructor_range_stack
;
4435 struct spelling
*spelling
;
4436 struct spelling
*spelling_base
;
4439 char require_constant_value
;
4440 char require_constant_elements
;
4443 struct initializer_stack
*initializer_stack
;
4445 /* Prepare to parse and output the initializer for variable DECL. */
4448 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
)
4451 struct initializer_stack
*p
= xmalloc (sizeof (struct initializer_stack
));
4453 p
->decl
= constructor_decl
;
4454 p
->require_constant_value
= require_constant_value
;
4455 p
->require_constant_elements
= require_constant_elements
;
4456 p
->constructor_stack
= constructor_stack
;
4457 p
->constructor_range_stack
= constructor_range_stack
;
4458 p
->elements
= constructor_elements
;
4459 p
->spelling
= spelling
;
4460 p
->spelling_base
= spelling_base
;
4461 p
->spelling_size
= spelling_size
;
4462 p
->top_level
= constructor_top_level
;
4463 p
->next
= initializer_stack
;
4464 initializer_stack
= p
;
4466 constructor_decl
= decl
;
4467 constructor_designated
= 0;
4468 constructor_top_level
= top_level
;
4470 if (decl
!= 0 && decl
!= error_mark_node
)
4472 require_constant_value
= TREE_STATIC (decl
);
4473 require_constant_elements
4474 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
4475 /* For a scalar, you can always use any value to initialize,
4476 even within braces. */
4477 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
4478 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
4479 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
4480 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
4481 locus
= IDENTIFIER_POINTER (DECL_NAME (decl
));
4485 require_constant_value
= 0;
4486 require_constant_elements
= 0;
4487 locus
= "(anonymous)";
4490 constructor_stack
= 0;
4491 constructor_range_stack
= 0;
4493 missing_braces_mentioned
= 0;
4497 RESTORE_SPELLING_DEPTH (0);
4500 push_string (locus
);
4506 struct initializer_stack
*p
= initializer_stack
;
4508 /* Free the whole constructor stack of this initializer. */
4509 while (constructor_stack
)
4511 struct constructor_stack
*q
= constructor_stack
;
4512 constructor_stack
= q
->next
;
4516 gcc_assert (!constructor_range_stack
);
4518 /* Pop back to the data of the outer initializer (if any). */
4519 free (spelling_base
);
4521 constructor_decl
= p
->decl
;
4522 require_constant_value
= p
->require_constant_value
;
4523 require_constant_elements
= p
->require_constant_elements
;
4524 constructor_stack
= p
->constructor_stack
;
4525 constructor_range_stack
= p
->constructor_range_stack
;
4526 constructor_elements
= p
->elements
;
4527 spelling
= p
->spelling
;
4528 spelling_base
= p
->spelling_base
;
4529 spelling_size
= p
->spelling_size
;
4530 constructor_top_level
= p
->top_level
;
4531 initializer_stack
= p
->next
;
4535 /* Call here when we see the initializer is surrounded by braces.
4536 This is instead of a call to push_init_level;
4537 it is matched by a call to pop_init_level.
4539 TYPE is the type to initialize, for a constructor expression.
4540 For an initializer for a decl, TYPE is zero. */
4543 really_start_incremental_init (tree type
)
4545 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
4548 type
= TREE_TYPE (constructor_decl
);
4550 if (targetm
.vector_opaque_p (type
))
4551 error ("opaque vector types cannot be initialized");
4553 p
->type
= constructor_type
;
4554 p
->fields
= constructor_fields
;
4555 p
->index
= constructor_index
;
4556 p
->max_index
= constructor_max_index
;
4557 p
->unfilled_index
= constructor_unfilled_index
;
4558 p
->unfilled_fields
= constructor_unfilled_fields
;
4559 p
->bit_index
= constructor_bit_index
;
4560 p
->elements
= constructor_elements
;
4561 p
->constant
= constructor_constant
;
4562 p
->simple
= constructor_simple
;
4563 p
->erroneous
= constructor_erroneous
;
4564 p
->pending_elts
= constructor_pending_elts
;
4565 p
->depth
= constructor_depth
;
4566 p
->replacement_value
.value
= 0;
4567 p
->replacement_value
.original_code
= ERROR_MARK
;
4571 p
->incremental
= constructor_incremental
;
4572 p
->designated
= constructor_designated
;
4574 constructor_stack
= p
;
4576 constructor_constant
= 1;
4577 constructor_simple
= 1;
4578 constructor_depth
= SPELLING_DEPTH ();
4579 constructor_elements
= 0;
4580 constructor_pending_elts
= 0;
4581 constructor_type
= type
;
4582 constructor_incremental
= 1;
4583 constructor_designated
= 0;
4584 designator_depth
= 0;
4585 designator_errorneous
= 0;
4587 if (TREE_CODE (constructor_type
) == RECORD_TYPE
4588 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4590 constructor_fields
= TYPE_FIELDS (constructor_type
);
4591 /* Skip any nameless bit fields at the beginning. */
4592 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
4593 && DECL_NAME (constructor_fields
) == 0)
4594 constructor_fields
= TREE_CHAIN (constructor_fields
);
4596 constructor_unfilled_fields
= constructor_fields
;
4597 constructor_bit_index
= bitsize_zero_node
;
4599 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4601 if (TYPE_DOMAIN (constructor_type
))
4603 constructor_max_index
4604 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
4606 /* Detect non-empty initializations of zero-length arrays. */
4607 if (constructor_max_index
== NULL_TREE
4608 && TYPE_SIZE (constructor_type
))
4609 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4611 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4612 to initialize VLAs will cause a proper error; avoid tree
4613 checking errors as well by setting a safe value. */
4614 if (constructor_max_index
4615 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
4616 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4619 = convert (bitsizetype
,
4620 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
4623 constructor_index
= bitsize_zero_node
;
4625 constructor_unfilled_index
= constructor_index
;
4627 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
4629 /* Vectors are like simple fixed-size arrays. */
4630 constructor_max_index
=
4631 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
4632 constructor_index
= convert (bitsizetype
, bitsize_zero_node
);
4633 constructor_unfilled_index
= constructor_index
;
4637 /* Handle the case of int x = {5}; */
4638 constructor_fields
= constructor_type
;
4639 constructor_unfilled_fields
= constructor_type
;
4643 /* Push down into a subobject, for initialization.
4644 If this is for an explicit set of braces, IMPLICIT is 0.
4645 If it is because the next element belongs at a lower level,
4646 IMPLICIT is 1 (or 2 if the push is because of designator list). */
4649 push_init_level (int implicit
)
4651 struct constructor_stack
*p
;
4652 tree value
= NULL_TREE
;
4654 /* If we've exhausted any levels that didn't have braces,
4656 while (constructor_stack
->implicit
)
4658 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
4659 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4660 && constructor_fields
== 0)
4661 process_init_element (pop_init_level (1));
4662 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
4663 && constructor_max_index
4664 && tree_int_cst_lt (constructor_max_index
, constructor_index
))
4665 process_init_element (pop_init_level (1));
4670 /* Unless this is an explicit brace, we need to preserve previous
4674 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
4675 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4676 && constructor_fields
)
4677 value
= find_init_member (constructor_fields
);
4678 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4679 value
= find_init_member (constructor_index
);
4682 p
= XNEW (struct constructor_stack
);
4683 p
->type
= constructor_type
;
4684 p
->fields
= constructor_fields
;
4685 p
->index
= constructor_index
;
4686 p
->max_index
= constructor_max_index
;
4687 p
->unfilled_index
= constructor_unfilled_index
;
4688 p
->unfilled_fields
= constructor_unfilled_fields
;
4689 p
->bit_index
= constructor_bit_index
;
4690 p
->elements
= constructor_elements
;
4691 p
->constant
= constructor_constant
;
4692 p
->simple
= constructor_simple
;
4693 p
->erroneous
= constructor_erroneous
;
4694 p
->pending_elts
= constructor_pending_elts
;
4695 p
->depth
= constructor_depth
;
4696 p
->replacement_value
.value
= 0;
4697 p
->replacement_value
.original_code
= ERROR_MARK
;
4698 p
->implicit
= implicit
;
4700 p
->incremental
= constructor_incremental
;
4701 p
->designated
= constructor_designated
;
4702 p
->next
= constructor_stack
;
4704 constructor_stack
= p
;
4706 constructor_constant
= 1;
4707 constructor_simple
= 1;
4708 constructor_depth
= SPELLING_DEPTH ();
4709 constructor_elements
= 0;
4710 constructor_incremental
= 1;
4711 constructor_designated
= 0;
4712 constructor_pending_elts
= 0;
4715 p
->range_stack
= constructor_range_stack
;
4716 constructor_range_stack
= 0;
4717 designator_depth
= 0;
4718 designator_errorneous
= 0;
4721 /* Don't die if an entire brace-pair level is superfluous
4722 in the containing level. */
4723 if (constructor_type
== 0)
4725 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
4726 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4728 /* Don't die if there are extra init elts at the end. */
4729 if (constructor_fields
== 0)
4730 constructor_type
= 0;
4733 constructor_type
= TREE_TYPE (constructor_fields
);
4734 push_member_name (constructor_fields
);
4735 constructor_depth
++;
4738 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4740 constructor_type
= TREE_TYPE (constructor_type
);
4741 push_array_bounds (tree_low_cst (constructor_index
, 0));
4742 constructor_depth
++;
4745 if (constructor_type
== 0)
4747 error_init ("extra brace group at end of initializer");
4748 constructor_fields
= 0;
4749 constructor_unfilled_fields
= 0;
4753 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
4755 constructor_constant
= TREE_CONSTANT (value
);
4756 constructor_simple
= TREE_STATIC (value
);
4757 constructor_elements
= CONSTRUCTOR_ELTS (value
);
4758 if (constructor_elements
4759 && (TREE_CODE (constructor_type
) == RECORD_TYPE
4760 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
4761 set_nonincremental_init ();
4764 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
4766 missing_braces_mentioned
= 1;
4767 warning_init ("missing braces around initializer");
4770 if (TREE_CODE (constructor_type
) == RECORD_TYPE
4771 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4773 constructor_fields
= TYPE_FIELDS (constructor_type
);
4774 /* Skip any nameless bit fields at the beginning. */
4775 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
4776 && DECL_NAME (constructor_fields
) == 0)
4777 constructor_fields
= TREE_CHAIN (constructor_fields
);
4779 constructor_unfilled_fields
= constructor_fields
;
4780 constructor_bit_index
= bitsize_zero_node
;
4782 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
4784 /* Vectors are like simple fixed-size arrays. */
4785 constructor_max_index
=
4786 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
4787 constructor_index
= convert (bitsizetype
, integer_zero_node
);
4788 constructor_unfilled_index
= constructor_index
;
4790 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4792 if (TYPE_DOMAIN (constructor_type
))
4794 constructor_max_index
4795 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
4797 /* Detect non-empty initializations of zero-length arrays. */
4798 if (constructor_max_index
== NULL_TREE
4799 && TYPE_SIZE (constructor_type
))
4800 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4802 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4803 to initialize VLAs will cause a proper error; avoid tree
4804 checking errors as well by setting a safe value. */
4805 if (constructor_max_index
4806 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
4807 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4810 = convert (bitsizetype
,
4811 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
4814 constructor_index
= bitsize_zero_node
;
4816 constructor_unfilled_index
= constructor_index
;
4817 if (value
&& TREE_CODE (value
) == STRING_CST
)
4819 /* We need to split the char/wchar array into individual
4820 characters, so that we don't have to special case it
4822 set_nonincremental_init_from_string (value
);
4827 warning_init ("braces around scalar initializer");
4828 constructor_fields
= constructor_type
;
4829 constructor_unfilled_fields
= constructor_type
;
4833 /* At the end of an implicit or explicit brace level,
4834 finish up that level of constructor. If a single expression
4835 with redundant braces initialized that level, return the
4836 c_expr structure for that expression. Otherwise, the original_code
4837 element is set to ERROR_MARK.
4838 If we were outputting the elements as they are read, return 0 as the value
4839 from inner levels (process_init_element ignores that),
4840 but return error_mark_node as the value from the outermost level
4841 (that's what we want to put in DECL_INITIAL).
4842 Otherwise, return a CONSTRUCTOR expression as the value. */
4845 pop_init_level (int implicit
)
4847 struct constructor_stack
*p
;
4850 ret
.original_code
= ERROR_MARK
;
4854 /* When we come to an explicit close brace,
4855 pop any inner levels that didn't have explicit braces. */
4856 while (constructor_stack
->implicit
)
4857 process_init_element (pop_init_level (1));
4859 gcc_assert (!constructor_range_stack
);
4862 /* Now output all pending elements. */
4863 constructor_incremental
= 1;
4864 output_pending_init_elements (1);
4866 p
= constructor_stack
;
4868 /* Error for initializing a flexible array member, or a zero-length
4869 array member in an inappropriate context. */
4870 if (constructor_type
&& constructor_fields
4871 && TREE_CODE (constructor_type
) == ARRAY_TYPE
4872 && TYPE_DOMAIN (constructor_type
)
4873 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
4875 /* Silently discard empty initializations. The parser will
4876 already have pedwarned for empty brackets. */
4877 if (integer_zerop (constructor_unfilled_index
))
4878 constructor_type
= NULL_TREE
;
4881 gcc_assert (!TYPE_SIZE (constructor_type
));
4883 if (constructor_depth
> 2)
4884 error_init ("initialization of flexible array member in a nested context");
4886 pedwarn_init ("initialization of a flexible array member");
4888 /* We have already issued an error message for the existence
4889 of a flexible array member not at the end of the structure.
4890 Discard the initializer so that we do not abort later. */
4891 if (TREE_CHAIN (constructor_fields
) != NULL_TREE
)
4892 constructor_type
= NULL_TREE
;
4896 /* Warn when some struct elements are implicitly initialized to zero. */
4897 if (warn_missing_field_initializers
4899 && TREE_CODE (constructor_type
) == RECORD_TYPE
4900 && constructor_unfilled_fields
)
4902 /* Do not warn for flexible array members or zero-length arrays. */
4903 while (constructor_unfilled_fields
4904 && (!DECL_SIZE (constructor_unfilled_fields
)
4905 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
4906 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
4908 /* Do not warn if this level of the initializer uses member
4909 designators; it is likely to be deliberate. */
4910 if (constructor_unfilled_fields
&& !constructor_designated
)
4912 push_member_name (constructor_unfilled_fields
);
4913 warning_init ("missing initializer");
4914 RESTORE_SPELLING_DEPTH (constructor_depth
);
4918 /* Pad out the end of the structure. */
4919 if (p
->replacement_value
.value
)
4920 /* If this closes a superfluous brace pair,
4921 just pass out the element between them. */
4922 ret
= p
->replacement_value
;
4923 else if (constructor_type
== 0)
4925 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
4926 && TREE_CODE (constructor_type
) != UNION_TYPE
4927 && TREE_CODE (constructor_type
) != ARRAY_TYPE
4928 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
4930 /* A nonincremental scalar initializer--just return
4931 the element, after verifying there is just one. */
4932 if (constructor_elements
== 0)
4934 if (!constructor_erroneous
)
4935 error_init ("empty scalar initializer");
4936 ret
.value
= error_mark_node
;
4938 else if (TREE_CHAIN (constructor_elements
) != 0)
4940 error_init ("extra elements in scalar initializer");
4941 ret
.value
= TREE_VALUE (constructor_elements
);
4944 ret
.value
= TREE_VALUE (constructor_elements
);
4948 if (constructor_erroneous
)
4949 ret
.value
= error_mark_node
;
4952 ret
.value
= build_constructor (constructor_type
,
4953 nreverse (constructor_elements
));
4954 if (constructor_constant
)
4955 TREE_CONSTANT (ret
.value
) = TREE_INVARIANT (ret
.value
) = 1;
4956 if (constructor_constant
&& constructor_simple
)
4957 TREE_STATIC (ret
.value
) = 1;
4961 constructor_type
= p
->type
;
4962 constructor_fields
= p
->fields
;
4963 constructor_index
= p
->index
;
4964 constructor_max_index
= p
->max_index
;
4965 constructor_unfilled_index
= p
->unfilled_index
;
4966 constructor_unfilled_fields
= p
->unfilled_fields
;
4967 constructor_bit_index
= p
->bit_index
;
4968 constructor_elements
= p
->elements
;
4969 constructor_constant
= p
->constant
;
4970 constructor_simple
= p
->simple
;
4971 constructor_erroneous
= p
->erroneous
;
4972 constructor_incremental
= p
->incremental
;
4973 constructor_designated
= p
->designated
;
4974 constructor_pending_elts
= p
->pending_elts
;
4975 constructor_depth
= p
->depth
;
4977 constructor_range_stack
= p
->range_stack
;
4978 RESTORE_SPELLING_DEPTH (constructor_depth
);
4980 constructor_stack
= p
->next
;
4985 if (constructor_stack
== 0)
4987 ret
.value
= error_mark_node
;
4995 /* Common handling for both array range and field name designators.
4996 ARRAY argument is nonzero for array ranges. Returns zero for success. */
4999 set_designator (int array
)
5002 enum tree_code subcode
;
5004 /* Don't die if an entire brace-pair level is superfluous
5005 in the containing level. */
5006 if (constructor_type
== 0)
5009 /* If there were errors in this designator list already, bail out
5011 if (designator_errorneous
)
5014 if (!designator_depth
)
5016 gcc_assert (!constructor_range_stack
);
5018 /* Designator list starts at the level of closest explicit
5020 while (constructor_stack
->implicit
)
5021 process_init_element (pop_init_level (1));
5022 constructor_designated
= 1;
5026 switch (TREE_CODE (constructor_type
))
5030 subtype
= TREE_TYPE (constructor_fields
);
5031 if (subtype
!= error_mark_node
)
5032 subtype
= TYPE_MAIN_VARIANT (subtype
);
5035 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
5041 subcode
= TREE_CODE (subtype
);
5042 if (array
&& subcode
!= ARRAY_TYPE
)
5044 error_init ("array index in non-array initializer");
5047 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
5049 error_init ("field name not in record or union initializer");
5053 constructor_designated
= 1;
5054 push_init_level (2);
5058 /* If there are range designators in designator list, push a new designator
5059 to constructor_range_stack. RANGE_END is end of such stack range or
5060 NULL_TREE if there is no range designator at this level. */
5063 push_range_stack (tree range_end
)
5065 struct constructor_range_stack
*p
;
5067 p
= GGC_NEW (struct constructor_range_stack
);
5068 p
->prev
= constructor_range_stack
;
5070 p
->fields
= constructor_fields
;
5071 p
->range_start
= constructor_index
;
5072 p
->index
= constructor_index
;
5073 p
->stack
= constructor_stack
;
5074 p
->range_end
= range_end
;
5075 if (constructor_range_stack
)
5076 constructor_range_stack
->next
= p
;
5077 constructor_range_stack
= p
;
5080 /* Within an array initializer, specify the next index to be initialized.
5081 FIRST is that index. If LAST is nonzero, then initialize a range
5082 of indices, running from FIRST through LAST. */
5085 set_init_index (tree first
, tree last
)
5087 if (set_designator (1))
5090 designator_errorneous
= 1;
5092 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
5093 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
5095 error_init ("array index in initializer not of integer type");
5099 while ((TREE_CODE (first
) == NOP_EXPR
5100 || TREE_CODE (first
) == CONVERT_EXPR
5101 || TREE_CODE (first
) == NON_LVALUE_EXPR
)
5102 && (TYPE_MODE (TREE_TYPE (first
))
5103 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first
, 0)))))
5104 first
= TREE_OPERAND (first
, 0);
5107 while ((TREE_CODE (last
) == NOP_EXPR
5108 || TREE_CODE (last
) == CONVERT_EXPR
5109 || TREE_CODE (last
) == NON_LVALUE_EXPR
)
5110 && (TYPE_MODE (TREE_TYPE (last
))
5111 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last
, 0)))))
5112 last
= TREE_OPERAND (last
, 0);
5114 if (TREE_CODE (first
) != INTEGER_CST
)
5115 error_init ("nonconstant array index in initializer");
5116 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
5117 error_init ("nonconstant array index in initializer");
5118 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5119 error_init ("array index in non-array initializer");
5120 else if (tree_int_cst_sgn (first
) == -1)
5121 error_init ("array index in initializer exceeds array bounds");
5122 else if (constructor_max_index
5123 && tree_int_cst_lt (constructor_max_index
, first
))
5124 error_init ("array index in initializer exceeds array bounds");
5127 constructor_index
= convert (bitsizetype
, first
);
5131 if (tree_int_cst_equal (first
, last
))
5133 else if (tree_int_cst_lt (last
, first
))
5135 error_init ("empty index range in initializer");
5140 last
= convert (bitsizetype
, last
);
5141 if (constructor_max_index
!= 0
5142 && tree_int_cst_lt (constructor_max_index
, last
))
5144 error_init ("array index range in initializer exceeds array bounds");
5151 designator_errorneous
= 0;
5152 if (constructor_range_stack
|| last
)
5153 push_range_stack (last
);
5157 /* Within a struct initializer, specify the next field to be initialized. */
5160 set_init_label (tree fieldname
)
5164 if (set_designator (0))
5167 designator_errorneous
= 1;
5169 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5170 && TREE_CODE (constructor_type
) != UNION_TYPE
)
5172 error_init ("field name not in record or union initializer");
5176 for (tail
= TYPE_FIELDS (constructor_type
); tail
;
5177 tail
= TREE_CHAIN (tail
))
5179 if (DECL_NAME (tail
) == fieldname
)
5184 error ("unknown field %qs specified in initializer",
5185 IDENTIFIER_POINTER (fieldname
));
5188 constructor_fields
= tail
;
5190 designator_errorneous
= 0;
5191 if (constructor_range_stack
)
5192 push_range_stack (NULL_TREE
);
5196 /* Add a new initializer to the tree of pending initializers. PURPOSE
5197 identifies the initializer, either array index or field in a structure.
5198 VALUE is the value of that index or field. */
5201 add_pending_init (tree purpose
, tree value
)
5203 struct init_node
*p
, **q
, *r
;
5205 q
= &constructor_pending_elts
;
5208 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5213 if (tree_int_cst_lt (purpose
, p
->purpose
))
5215 else if (tree_int_cst_lt (p
->purpose
, purpose
))
5219 if (TREE_SIDE_EFFECTS (p
->value
))
5220 warning_init ("initialized field with side-effects overwritten");
5230 bitpos
= bit_position (purpose
);
5234 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5236 else if (p
->purpose
!= purpose
)
5240 if (TREE_SIDE_EFFECTS (p
->value
))
5241 warning_init ("initialized field with side-effects overwritten");
5248 r
= GGC_NEW (struct init_node
);
5249 r
->purpose
= purpose
;
5260 struct init_node
*s
;
5264 if (p
->balance
== 0)
5266 else if (p
->balance
< 0)
5273 p
->left
->parent
= p
;
5290 constructor_pending_elts
= r
;
5295 struct init_node
*t
= r
->right
;
5299 r
->right
->parent
= r
;
5304 p
->left
->parent
= p
;
5307 p
->balance
= t
->balance
< 0;
5308 r
->balance
= -(t
->balance
> 0);
5323 constructor_pending_elts
= t
;
5329 /* p->balance == +1; growth of left side balances the node. */
5334 else /* r == p->right */
5336 if (p
->balance
== 0)
5337 /* Growth propagation from right side. */
5339 else if (p
->balance
> 0)
5346 p
->right
->parent
= p
;
5363 constructor_pending_elts
= r
;
5365 else /* r->balance == -1 */
5368 struct init_node
*t
= r
->left
;
5372 r
->left
->parent
= r
;
5377 p
->right
->parent
= p
;
5380 r
->balance
= (t
->balance
< 0);
5381 p
->balance
= -(t
->balance
> 0);
5396 constructor_pending_elts
= t
;
5402 /* p->balance == -1; growth of right side balances the node. */
5413 /* Build AVL tree from a sorted chain. */
5416 set_nonincremental_init (void)
5420 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5421 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5424 for (chain
= constructor_elements
; chain
; chain
= TREE_CHAIN (chain
))
5425 add_pending_init (TREE_PURPOSE (chain
), TREE_VALUE (chain
));
5426 constructor_elements
= 0;
5427 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5429 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
5430 /* Skip any nameless bit fields at the beginning. */
5431 while (constructor_unfilled_fields
!= 0
5432 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
5433 && DECL_NAME (constructor_unfilled_fields
) == 0)
5434 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
5437 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5439 if (TYPE_DOMAIN (constructor_type
))
5440 constructor_unfilled_index
5441 = convert (bitsizetype
,
5442 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
5444 constructor_unfilled_index
= bitsize_zero_node
;
5446 constructor_incremental
= 0;
5449 /* Build AVL tree from a string constant. */
5452 set_nonincremental_init_from_string (tree str
)
5454 tree value
, purpose
, type
;
5455 HOST_WIDE_INT val
[2];
5456 const char *p
, *end
;
5457 int byte
, wchar_bytes
, charwidth
, bitpos
;
5459 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
5461 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
5462 == TYPE_PRECISION (char_type_node
))
5466 gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
5467 == TYPE_PRECISION (wchar_type_node
));
5468 wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
5470 charwidth
= TYPE_PRECISION (char_type_node
);
5471 type
= TREE_TYPE (constructor_type
);
5472 p
= TREE_STRING_POINTER (str
);
5473 end
= p
+ TREE_STRING_LENGTH (str
);
5475 for (purpose
= bitsize_zero_node
;
5476 p
< end
&& !tree_int_cst_lt (constructor_max_index
, purpose
);
5477 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
5479 if (wchar_bytes
== 1)
5481 val
[1] = (unsigned char) *p
++;
5488 for (byte
= 0; byte
< wchar_bytes
; byte
++)
5490 if (BYTES_BIG_ENDIAN
)
5491 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
5493 bitpos
= byte
* charwidth
;
5494 val
[bitpos
< HOST_BITS_PER_WIDE_INT
]
5495 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
5496 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
5500 if (!TYPE_UNSIGNED (type
))
5502 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
5503 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5505 if (val
[1] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
5507 val
[1] |= ((HOST_WIDE_INT
) -1) << bitpos
;
5511 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
5516 else if (val
[0] & (((HOST_WIDE_INT
) 1)
5517 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
5518 val
[0] |= ((HOST_WIDE_INT
) -1)
5519 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5522 value
= build_int_cst_wide (type
, val
[1], val
[0]);
5523 add_pending_init (purpose
, value
);
5526 constructor_incremental
= 0;
5529 /* Return value of FIELD in pending initializer or zero if the field was
5530 not initialized yet. */
5533 find_init_member (tree field
)
5535 struct init_node
*p
;
5537 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5539 if (constructor_incremental
5540 && tree_int_cst_lt (field
, constructor_unfilled_index
))
5541 set_nonincremental_init ();
5543 p
= constructor_pending_elts
;
5546 if (tree_int_cst_lt (field
, p
->purpose
))
5548 else if (tree_int_cst_lt (p
->purpose
, field
))
5554 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5556 tree bitpos
= bit_position (field
);
5558 if (constructor_incremental
5559 && (!constructor_unfilled_fields
5560 || tree_int_cst_lt (bitpos
,
5561 bit_position (constructor_unfilled_fields
))))
5562 set_nonincremental_init ();
5564 p
= constructor_pending_elts
;
5567 if (field
== p
->purpose
)
5569 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5575 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
5577 if (constructor_elements
5578 && TREE_PURPOSE (constructor_elements
) == field
)
5579 return TREE_VALUE (constructor_elements
);
5584 /* "Output" the next constructor element.
5585 At top level, really output it to assembler code now.
5586 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5587 TYPE is the data type that the containing data type wants here.
5588 FIELD is the field (a FIELD_DECL) or the index that this element fills.
5589 If VALUE is a string constant, STRICT_STRING is true if it is
5590 unparenthesized or we should not warn here for it being parenthesized.
5591 For other types of VALUE, STRICT_STRING is not used.
5593 PENDING if non-nil means output pending elements that belong
5594 right after this element. (PENDING is normally 1;
5595 it is 0 while outputting pending elements, to avoid recursion.) */
5598 output_init_element (tree value
, bool strict_string
, tree type
, tree field
,
5601 if (type
== error_mark_node
|| value
== error_mark_node
)
5603 constructor_erroneous
= 1;
5606 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5607 || (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5608 && !(TREE_CODE (value
) == STRING_CST
5609 && TREE_CODE (type
) == ARRAY_TYPE
5610 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
5611 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
5612 TYPE_MAIN_VARIANT (type
))))
5613 value
= default_conversion (value
);
5615 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
5616 && require_constant_value
&& !flag_isoc99
&& pending
)
5618 /* As an extension, allow initializing objects with static storage
5619 duration with compound literals (which are then treated just as
5620 the brace enclosed list they contain). */
5621 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
5622 value
= DECL_INITIAL (decl
);
5625 if (value
== error_mark_node
)
5626 constructor_erroneous
= 1;
5627 else if (!TREE_CONSTANT (value
))
5628 constructor_constant
= 0;
5629 else if (!initializer_constant_valid_p (value
, TREE_TYPE (value
))
5630 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
5631 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5632 && DECL_C_BIT_FIELD (field
)
5633 && TREE_CODE (value
) != INTEGER_CST
))
5634 constructor_simple
= 0;
5636 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
5638 if (require_constant_value
)
5640 error_init ("initializer element is not constant");
5641 value
= error_mark_node
;
5643 else if (require_constant_elements
)
5644 pedwarn ("initializer element is not computable at load time");
5647 /* If this field is empty (and not at the end of structure),
5648 don't do anything other than checking the initializer. */
5650 && (TREE_TYPE (field
) == error_mark_node
5651 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
5652 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
5653 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
5654 || TREE_CHAIN (field
)))))
5657 value
= digest_init (type
, value
, strict_string
, require_constant_value
);
5658 if (value
== error_mark_node
)
5660 constructor_erroneous
= 1;
5664 /* If this element doesn't come next in sequence,
5665 put it on constructor_pending_elts. */
5666 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
5667 && (!constructor_incremental
5668 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
5670 if (constructor_incremental
5671 && tree_int_cst_lt (field
, constructor_unfilled_index
))
5672 set_nonincremental_init ();
5674 add_pending_init (field
, value
);
5677 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5678 && (!constructor_incremental
5679 || field
!= constructor_unfilled_fields
))
5681 /* We do this for records but not for unions. In a union,
5682 no matter which field is specified, it can be initialized
5683 right away since it starts at the beginning of the union. */
5684 if (constructor_incremental
)
5686 if (!constructor_unfilled_fields
)
5687 set_nonincremental_init ();
5690 tree bitpos
, unfillpos
;
5692 bitpos
= bit_position (field
);
5693 unfillpos
= bit_position (constructor_unfilled_fields
);
5695 if (tree_int_cst_lt (bitpos
, unfillpos
))
5696 set_nonincremental_init ();
5700 add_pending_init (field
, value
);
5703 else if (TREE_CODE (constructor_type
) == UNION_TYPE
5704 && constructor_elements
)
5706 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements
)))
5707 warning_init ("initialized field with side-effects overwritten");
5709 /* We can have just one union field set. */
5710 constructor_elements
= 0;
5713 /* Otherwise, output this element either to
5714 constructor_elements or to the assembler file. */
5716 if (field
&& TREE_CODE (field
) == INTEGER_CST
)
5717 field
= copy_node (field
);
5718 constructor_elements
5719 = tree_cons (field
, value
, constructor_elements
);
5721 /* Advance the variable that indicates sequential elements output. */
5722 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5723 constructor_unfilled_index
5724 = size_binop (PLUS_EXPR
, constructor_unfilled_index
,
5726 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5728 constructor_unfilled_fields
5729 = TREE_CHAIN (constructor_unfilled_fields
);
5731 /* Skip any nameless bit fields. */
5732 while (constructor_unfilled_fields
!= 0
5733 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
5734 && DECL_NAME (constructor_unfilled_fields
) == 0)
5735 constructor_unfilled_fields
=
5736 TREE_CHAIN (constructor_unfilled_fields
);
5738 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
5739 constructor_unfilled_fields
= 0;
5741 /* Now output any pending elements which have become next. */
5743 output_pending_init_elements (0);
5746 /* Output any pending elements which have become next.
5747 As we output elements, constructor_unfilled_{fields,index}
5748 advances, which may cause other elements to become next;
5749 if so, they too are output.
5751 If ALL is 0, we return when there are
5752 no more pending elements to output now.
5754 If ALL is 1, we output space as necessary so that
5755 we can output all the pending elements. */
5758 output_pending_init_elements (int all
)
5760 struct init_node
*elt
= constructor_pending_elts
;
5765 /* Look through the whole pending tree.
5766 If we find an element that should be output now,
5767 output it. Otherwise, set NEXT to the element
5768 that comes first among those still pending. */
5773 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5775 if (tree_int_cst_equal (elt
->purpose
,
5776 constructor_unfilled_index
))
5777 output_init_element (elt
->value
, true,
5778 TREE_TYPE (constructor_type
),
5779 constructor_unfilled_index
, 0);
5780 else if (tree_int_cst_lt (constructor_unfilled_index
,
5783 /* Advance to the next smaller node. */
5788 /* We have reached the smallest node bigger than the
5789 current unfilled index. Fill the space first. */
5790 next
= elt
->purpose
;
5796 /* Advance to the next bigger node. */
5801 /* We have reached the biggest node in a subtree. Find
5802 the parent of it, which is the next bigger node. */
5803 while (elt
->parent
&& elt
->parent
->right
== elt
)
5806 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
5809 next
= elt
->purpose
;
5815 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5816 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5818 tree ctor_unfilled_bitpos
, elt_bitpos
;
5820 /* If the current record is complete we are done. */
5821 if (constructor_unfilled_fields
== 0)
5824 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
5825 elt_bitpos
= bit_position (elt
->purpose
);
5826 /* We can't compare fields here because there might be empty
5827 fields in between. */
5828 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
5830 constructor_unfilled_fields
= elt
->purpose
;
5831 output_init_element (elt
->value
, true, TREE_TYPE (elt
->purpose
),
5834 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
5836 /* Advance to the next smaller node. */
5841 /* We have reached the smallest node bigger than the
5842 current unfilled field. Fill the space first. */
5843 next
= elt
->purpose
;
5849 /* Advance to the next bigger node. */
5854 /* We have reached the biggest node in a subtree. Find
5855 the parent of it, which is the next bigger node. */
5856 while (elt
->parent
&& elt
->parent
->right
== elt
)
5860 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
5861 bit_position (elt
->purpose
))))
5863 next
= elt
->purpose
;
5871 /* Ordinarily return, but not if we want to output all
5872 and there are elements left. */
5873 if (!(all
&& next
!= 0))
5876 /* If it's not incremental, just skip over the gap, so that after
5877 jumping to retry we will output the next successive element. */
5878 if (TREE_CODE (constructor_type
) == RECORD_TYPE
5879 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5880 constructor_unfilled_fields
= next
;
5881 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5882 constructor_unfilled_index
= next
;
5884 /* ELT now points to the node in the pending tree with the next
5885 initializer to output. */
5889 /* Add one non-braced element to the current constructor level.
5890 This adjusts the current position within the constructor's type.
5891 This may also start or terminate implicit levels
5892 to handle a partly-braced initializer.
5894 Once this has found the correct level for the new element,
5895 it calls output_init_element. */
5898 process_init_element (struct c_expr value
)
5900 tree orig_value
= value
.value
;
5901 int string_flag
= orig_value
!= 0 && TREE_CODE (orig_value
) == STRING_CST
;
5902 bool strict_string
= value
.original_code
== STRING_CST
;
5904 designator_depth
= 0;
5905 designator_errorneous
= 0;
5907 /* Handle superfluous braces around string cst as in
5908 char x[] = {"foo"}; */
5911 && TREE_CODE (constructor_type
) == ARRAY_TYPE
5912 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
5913 && integer_zerop (constructor_unfilled_index
))
5915 if (constructor_stack
->replacement_value
.value
)
5916 error_init ("excess elements in char array initializer");
5917 constructor_stack
->replacement_value
= value
;
5921 if (constructor_stack
->replacement_value
.value
!= 0)
5923 error_init ("excess elements in struct initializer");
5927 /* Ignore elements of a brace group if it is entirely superfluous
5928 and has already been diagnosed. */
5929 if (constructor_type
== 0)
5932 /* If we've exhausted any levels that didn't have braces,
5934 while (constructor_stack
->implicit
)
5936 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
5937 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5938 && constructor_fields
== 0)
5939 process_init_element (pop_init_level (1));
5940 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
5941 && (constructor_max_index
== 0
5942 || tree_int_cst_lt (constructor_max_index
,
5943 constructor_index
)))
5944 process_init_element (pop_init_level (1));
5949 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
5950 if (constructor_range_stack
)
5952 /* If value is a compound literal and we'll be just using its
5953 content, don't put it into a SAVE_EXPR. */
5954 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
5955 || !require_constant_value
5957 value
.value
= save_expr (value
.value
);
5962 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5965 enum tree_code fieldcode
;
5967 if (constructor_fields
== 0)
5969 pedwarn_init ("excess elements in struct initializer");
5973 fieldtype
= TREE_TYPE (constructor_fields
);
5974 if (fieldtype
!= error_mark_node
)
5975 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
5976 fieldcode
= TREE_CODE (fieldtype
);
5978 /* Error for non-static initialization of a flexible array member. */
5979 if (fieldcode
== ARRAY_TYPE
5980 && !require_constant_value
5981 && TYPE_SIZE (fieldtype
) == NULL_TREE
5982 && TREE_CHAIN (constructor_fields
) == NULL_TREE
)
5984 error_init ("non-static initialization of a flexible array member");
5988 /* Accept a string constant to initialize a subarray. */
5989 if (value
.value
!= 0
5990 && fieldcode
== ARRAY_TYPE
5991 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
5993 value
.value
= orig_value
;
5994 /* Otherwise, if we have come to a subaggregate,
5995 and we don't have an element of its type, push into it. */
5996 else if (value
.value
!= 0
5997 && value
.value
!= error_mark_node
5998 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
5999 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6000 || fieldcode
== UNION_TYPE
))
6002 push_init_level (1);
6008 push_member_name (constructor_fields
);
6009 output_init_element (value
.value
, strict_string
,
6010 fieldtype
, constructor_fields
, 1);
6011 RESTORE_SPELLING_DEPTH (constructor_depth
);
6014 /* Do the bookkeeping for an element that was
6015 directly output as a constructor. */
6017 /* For a record, keep track of end position of last field. */
6018 if (DECL_SIZE (constructor_fields
))
6019 constructor_bit_index
6020 = size_binop (PLUS_EXPR
,
6021 bit_position (constructor_fields
),
6022 DECL_SIZE (constructor_fields
));
6024 /* If the current field was the first one not yet written out,
6025 it isn't now, so update. */
6026 if (constructor_unfilled_fields
== constructor_fields
)
6028 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6029 /* Skip any nameless bit fields. */
6030 while (constructor_unfilled_fields
!= 0
6031 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
6032 && DECL_NAME (constructor_unfilled_fields
) == 0)
6033 constructor_unfilled_fields
=
6034 TREE_CHAIN (constructor_unfilled_fields
);
6038 constructor_fields
= TREE_CHAIN (constructor_fields
);
6039 /* Skip any nameless bit fields at the beginning. */
6040 while (constructor_fields
!= 0
6041 && DECL_C_BIT_FIELD (constructor_fields
)
6042 && DECL_NAME (constructor_fields
) == 0)
6043 constructor_fields
= TREE_CHAIN (constructor_fields
);
6045 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
6048 enum tree_code fieldcode
;
6050 if (constructor_fields
== 0)
6052 pedwarn_init ("excess elements in union initializer");
6056 fieldtype
= TREE_TYPE (constructor_fields
);
6057 if (fieldtype
!= error_mark_node
)
6058 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6059 fieldcode
= TREE_CODE (fieldtype
);
6061 /* Warn that traditional C rejects initialization of unions.
6062 We skip the warning if the value is zero. This is done
6063 under the assumption that the zero initializer in user
6064 code appears conditioned on e.g. __STDC__ to avoid
6065 "missing initializer" warnings and relies on default
6066 initialization to zero in the traditional C case.
6067 We also skip the warning if the initializer is designated,
6068 again on the assumption that this must be conditional on
6069 __STDC__ anyway (and we've already complained about the
6070 member-designator already). */
6071 if (warn_traditional
&& !in_system_header
&& !constructor_designated
6072 && !(value
.value
&& (integer_zerop (value
.value
)
6073 || real_zerop (value
.value
))))
6074 warning ("traditional C rejects initialization of unions");
6076 /* Accept a string constant to initialize a subarray. */
6077 if (value
.value
!= 0
6078 && fieldcode
== ARRAY_TYPE
6079 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
6081 value
.value
= orig_value
;
6082 /* Otherwise, if we have come to a subaggregate,
6083 and we don't have an element of its type, push into it. */
6084 else if (value
.value
!= 0
6085 && value
.value
!= error_mark_node
6086 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
6087 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6088 || fieldcode
== UNION_TYPE
))
6090 push_init_level (1);
6096 push_member_name (constructor_fields
);
6097 output_init_element (value
.value
, strict_string
,
6098 fieldtype
, constructor_fields
, 1);
6099 RESTORE_SPELLING_DEPTH (constructor_depth
);
6102 /* Do the bookkeeping for an element that was
6103 directly output as a constructor. */
6105 constructor_bit_index
= DECL_SIZE (constructor_fields
);
6106 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6109 constructor_fields
= 0;
6111 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6113 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6114 enum tree_code eltcode
= TREE_CODE (elttype
);
6116 /* Accept a string constant to initialize a subarray. */
6117 if (value
.value
!= 0
6118 && eltcode
== ARRAY_TYPE
6119 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
6121 value
.value
= orig_value
;
6122 /* Otherwise, if we have come to a subaggregate,
6123 and we don't have an element of its type, push into it. */
6124 else if (value
.value
!= 0
6125 && value
.value
!= error_mark_node
6126 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
6127 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
6128 || eltcode
== UNION_TYPE
))
6130 push_init_level (1);
6134 if (constructor_max_index
!= 0
6135 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
6136 || integer_all_onesp (constructor_max_index
)))
6138 pedwarn_init ("excess elements in array initializer");
6142 /* Now output the actual element. */
6145 push_array_bounds (tree_low_cst (constructor_index
, 0));
6146 output_init_element (value
.value
, strict_string
,
6147 elttype
, constructor_index
, 1);
6148 RESTORE_SPELLING_DEPTH (constructor_depth
);
6152 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6155 /* If we are doing the bookkeeping for an element that was
6156 directly output as a constructor, we must update
6157 constructor_unfilled_index. */
6158 constructor_unfilled_index
= constructor_index
;
6160 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6162 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6164 /* Do a basic check of initializer size. Note that vectors
6165 always have a fixed size derived from their type. */
6166 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
6168 pedwarn_init ("excess elements in vector initializer");
6172 /* Now output the actual element. */
6174 output_init_element (value
.value
, strict_string
,
6175 elttype
, constructor_index
, 1);
6178 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6181 /* If we are doing the bookkeeping for an element that was
6182 directly output as a constructor, we must update
6183 constructor_unfilled_index. */
6184 constructor_unfilled_index
= constructor_index
;
6187 /* Handle the sole element allowed in a braced initializer
6188 for a scalar variable. */
6189 else if (constructor_fields
== 0)
6191 pedwarn_init ("excess elements in scalar initializer");
6197 output_init_element (value
.value
, strict_string
,
6198 constructor_type
, NULL_TREE
, 1);
6199 constructor_fields
= 0;
6202 /* Handle range initializers either at this level or anywhere higher
6203 in the designator stack. */
6204 if (constructor_range_stack
)
6206 struct constructor_range_stack
*p
, *range_stack
;
6209 range_stack
= constructor_range_stack
;
6210 constructor_range_stack
= 0;
6211 while (constructor_stack
!= range_stack
->stack
)
6213 gcc_assert (constructor_stack
->implicit
);
6214 process_init_element (pop_init_level (1));
6216 for (p
= range_stack
;
6217 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
6220 gcc_assert (constructor_stack
->implicit
);
6221 process_init_element (pop_init_level (1));
6224 p
->index
= size_binop (PLUS_EXPR
, p
->index
, bitsize_one_node
);
6225 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
6230 constructor_index
= p
->index
;
6231 constructor_fields
= p
->fields
;
6232 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
6240 push_init_level (2);
6241 p
->stack
= constructor_stack
;
6242 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
6243 p
->index
= p
->range_start
;
6247 constructor_range_stack
= range_stack
;
6254 constructor_range_stack
= 0;
6257 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6258 (guaranteed to be 'volatile' or null) and ARGS (represented using
6259 an ASM_EXPR node). */
6261 build_asm_stmt (tree cv_qualifier
, tree args
)
6263 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
6264 ASM_VOLATILE_P (args
) = 1;
6265 return add_stmt (args
);
6268 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6269 some INPUTS, and some CLOBBERS. The latter three may be NULL.
6270 SIMPLE indicates whether there was anything at all after the
6271 string in the asm expression -- asm("blah") and asm("blah" : )
6272 are subtly different. We use a ASM_EXPR node to represent this. */
6274 build_asm_expr (tree string
, tree outputs
, tree inputs
, tree clobbers
,
6280 const char *constraint
;
6281 const char **oconstraints
;
6282 bool allows_mem
, allows_reg
, is_inout
;
6283 int ninputs
, noutputs
;
6285 ninputs
= list_length (inputs
);
6286 noutputs
= list_length (outputs
);
6287 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
6289 string
= resolve_asm_operand_names (string
, outputs
, inputs
);
6291 /* Remove output conversions that change the type but not the mode. */
6292 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
6294 tree output
= TREE_VALUE (tail
);
6296 /* ??? Really, this should not be here. Users should be using a
6297 proper lvalue, dammit. But there's a long history of using casts
6298 in the output operands. In cases like longlong.h, this becomes a
6299 primitive form of typechecking -- if the cast can be removed, then
6300 the output operand had a type of the proper width; otherwise we'll
6301 get an error. Gross, but ... */
6302 STRIP_NOPS (output
);
6304 if (!lvalue_or_else (output
, lv_asm
))
6305 output
= error_mark_node
;
6307 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
6308 oconstraints
[i
] = constraint
;
6310 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
6311 &allows_mem
, &allows_reg
, &is_inout
))
6313 /* If the operand is going to end up in memory,
6314 mark it addressable. */
6315 if (!allows_reg
&& !c_mark_addressable (output
))
6316 output
= error_mark_node
;
6319 output
= error_mark_node
;
6321 TREE_VALUE (tail
) = output
;
6324 /* Perform default conversions on array and function inputs.
6325 Don't do this for other types as it would screw up operands
6326 expected to be in memory. */
6327 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
6331 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
6332 input
= TREE_VALUE (tail
);
6334 input
= default_function_array_conversion (input
);
6336 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
6337 oconstraints
, &allows_mem
, &allows_reg
))
6339 /* If the operand is going to end up in memory,
6340 mark it addressable. */
6341 if (!allows_reg
&& allows_mem
&& !c_mark_addressable (input
))
6342 input
= error_mark_node
;
6345 input
= error_mark_node
;
6347 TREE_VALUE (tail
) = input
;
6350 args
= build_stmt (ASM_EXPR
, string
, outputs
, inputs
, clobbers
);
6352 /* Simple asm statements are treated as volatile. */
6355 ASM_VOLATILE_P (args
) = 1;
6356 ASM_INPUT_P (args
) = 1;
6362 /* Generate a goto statement to LABEL. */
6365 c_finish_goto_label (tree label
)
6367 tree decl
= lookup_label (label
);
6371 TREE_USED (decl
) = 1;
6372 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, decl
));
6375 /* Generate a computed goto statement to EXPR. */
6378 c_finish_goto_ptr (tree expr
)
6381 pedwarn ("ISO C forbids %<goto *expr;%>");
6382 expr
= convert (ptr_type_node
, expr
);
6383 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, expr
));
6386 /* Generate a C `return' statement. RETVAL is the expression for what
6387 to return, or a null pointer for `return;' with no value. */
6390 c_finish_return (tree retval
)
6392 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
6394 if (TREE_THIS_VOLATILE (current_function_decl
))
6395 warning ("function declared %<noreturn%> has a %<return%> statement");
6399 current_function_returns_null
= 1;
6400 if ((warn_return_type
|| flag_isoc99
)
6401 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
6402 pedwarn_c99 ("%<return%> with no value, in "
6403 "function returning non-void");
6405 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
6407 current_function_returns_null
= 1;
6408 if (pedantic
|| TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
6409 pedwarn ("%<return%> with a value, in function returning void");
6413 tree t
= convert_for_assignment (valtype
, retval
, ic_return
,
6414 NULL_TREE
, NULL_TREE
, 0);
6415 tree res
= DECL_RESULT (current_function_decl
);
6418 current_function_returns_value
= 1;
6419 if (t
== error_mark_node
)
6422 inner
= t
= convert (TREE_TYPE (res
), t
);
6424 /* Strip any conversions, additions, and subtractions, and see if
6425 we are returning the address of a local variable. Warn if so. */
6428 switch (TREE_CODE (inner
))
6430 case NOP_EXPR
: case NON_LVALUE_EXPR
: case CONVERT_EXPR
:
6432 inner
= TREE_OPERAND (inner
, 0);
6436 /* If the second operand of the MINUS_EXPR has a pointer
6437 type (or is converted from it), this may be valid, so
6438 don't give a warning. */
6440 tree op1
= TREE_OPERAND (inner
, 1);
6442 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
6443 && (TREE_CODE (op1
) == NOP_EXPR
6444 || TREE_CODE (op1
) == NON_LVALUE_EXPR
6445 || TREE_CODE (op1
) == CONVERT_EXPR
))
6446 op1
= TREE_OPERAND (op1
, 0);
6448 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
6451 inner
= TREE_OPERAND (inner
, 0);
6456 inner
= TREE_OPERAND (inner
, 0);
6458 while (REFERENCE_CLASS_P (inner
)
6459 && TREE_CODE (inner
) != INDIRECT_REF
)
6460 inner
= TREE_OPERAND (inner
, 0);
6463 && !DECL_EXTERNAL (inner
)
6464 && !TREE_STATIC (inner
)
6465 && DECL_CONTEXT (inner
) == current_function_decl
)
6466 warning ("function returns address of local variable");
6476 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
6479 return add_stmt (build_stmt (RETURN_EXPR
, retval
));
6483 /* The SWITCH_STMT being built. */
6486 /* The original type of the testing expression, i.e. before the
6487 default conversion is applied. */
6490 /* A splay-tree mapping the low element of a case range to the high
6491 element, or NULL_TREE if there is no high element. Used to
6492 determine whether or not a new case label duplicates an old case
6493 label. We need a tree, rather than simply a hash table, because
6494 of the GNU case range extension. */
6497 /* The next node on the stack. */
6498 struct c_switch
*next
;
6501 /* A stack of the currently active switch statements. The innermost
6502 switch statement is on the top of the stack. There is no need to
6503 mark the stack for garbage collection because it is only active
6504 during the processing of the body of a function, and we never
6505 collect at that point. */
6507 struct c_switch
*c_switch_stack
;
6509 /* Start a C switch statement, testing expression EXP. Return the new
6513 c_start_case (tree exp
)
6515 enum tree_code code
;
6516 tree type
, orig_type
= error_mark_node
;
6517 struct c_switch
*cs
;
6519 if (exp
!= error_mark_node
)
6521 code
= TREE_CODE (TREE_TYPE (exp
));
6522 orig_type
= TREE_TYPE (exp
);
6524 if (!INTEGRAL_TYPE_P (orig_type
)
6525 && code
!= ERROR_MARK
)
6527 error ("switch quantity not an integer");
6528 exp
= integer_zero_node
;
6529 orig_type
= error_mark_node
;
6533 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
6535 if (warn_traditional
&& !in_system_header
6536 && (type
== long_integer_type_node
6537 || type
== long_unsigned_type_node
))
6538 warning ("%<long%> switch expression not converted to "
6539 "%<int%> in ISO C");
6541 exp
= default_conversion (exp
);
6542 type
= TREE_TYPE (exp
);
6546 /* Add this new SWITCH_STMT to the stack. */
6547 cs
= XNEW (struct c_switch
);
6548 cs
->switch_stmt
= build_stmt ((enum tree_code
) SWITCH_STMT
, exp
, NULL_TREE
,
6550 cs
->orig_type
= orig_type
;
6551 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
6552 cs
->next
= c_switch_stack
;
6553 c_switch_stack
= cs
;
6555 return add_stmt (cs
->switch_stmt
);
6558 /* Process a case label. */
6561 do_case (tree low_value
, tree high_value
)
6563 tree label
= NULL_TREE
;
6567 label
= c_add_case_label (c_switch_stack
->cases
,
6568 SWITCH_COND (c_switch_stack
->switch_stmt
),
6569 c_switch_stack
->orig_type
,
6570 low_value
, high_value
);
6571 if (label
== error_mark_node
)
6575 error ("case label not within a switch statement");
6577 error ("%<default%> label not within a switch statement");
6582 /* Finish the switch statement. */
6585 c_finish_case (tree body
)
6587 struct c_switch
*cs
= c_switch_stack
;
6589 SWITCH_BODY (cs
->switch_stmt
) = body
;
6591 /* Emit warnings as needed. */
6592 c_do_switch_warnings (cs
->cases
, cs
->switch_stmt
);
6594 /* Pop the stack. */
6595 c_switch_stack
= cs
->next
;
6596 splay_tree_delete (cs
->cases
);
6600 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
6601 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6602 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
6603 statement, and was not surrounded with parenthesis. */
6606 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
6607 tree else_block
, bool nested_if
)
6611 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
6612 if (warn_parentheses
&& nested_if
&& else_block
== NULL
)
6614 tree inner_if
= then_block
;
6616 /* We know from the grammar productions that there is an IF nested
6617 within THEN_BLOCK. Due to labels and c99 conditional declarations,
6618 it might not be exactly THEN_BLOCK, but should be the last
6619 non-container statement within. */
6621 switch (TREE_CODE (inner_if
))
6626 inner_if
= BIND_EXPR_BODY (inner_if
);
6628 case STATEMENT_LIST
:
6629 inner_if
= expr_last (then_block
);
6631 case TRY_FINALLY_EXPR
:
6632 case TRY_CATCH_EXPR
:
6633 inner_if
= TREE_OPERAND (inner_if
, 0);
6640 if (COND_EXPR_ELSE (inner_if
))
6641 warning ("%Hsuggest explicit braces to avoid ambiguous %<else%>",
6645 /* Diagnose ";" via the special empty statement node that we create. */
6648 if (TREE_CODE (then_block
) == NOP_EXPR
&& !TREE_TYPE (then_block
))
6651 warning ("%Hempty body in an if-statement",
6652 EXPR_LOCUS (then_block
));
6653 then_block
= alloc_stmt_list ();
6656 && TREE_CODE (else_block
) == NOP_EXPR
6657 && !TREE_TYPE (else_block
))
6659 warning ("%Hempty body in an else-statement",
6660 EXPR_LOCUS (else_block
));
6661 else_block
= alloc_stmt_list ();
6665 stmt
= build3 (COND_EXPR
, NULL_TREE
, cond
, then_block
, else_block
);
6666 SET_EXPR_LOCATION (stmt
, if_locus
);
6670 /* Emit a general-purpose loop construct. START_LOCUS is the location of
6671 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
6672 is false for DO loops. INCR is the FOR increment expression. BODY is
6673 the statement controlled by the loop. BLAB is the break label. CLAB is
6674 the continue label. Everything is allowed to be NULL. */
6677 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
6678 tree blab
, tree clab
, bool cond_is_first
)
6680 tree entry
= NULL
, exit
= NULL
, t
;
6682 /* If the condition is zero don't generate a loop construct. */
6683 if (cond
&& integer_zerop (cond
))
6687 t
= build_and_jump (&blab
);
6688 SET_EXPR_LOCATION (t
, start_locus
);
6694 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
6696 /* If we have an exit condition, then we build an IF with gotos either
6697 out of the loop, or to the top of it. If there's no exit condition,
6698 then we just build a jump back to the top. */
6699 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
6701 if (cond
&& !integer_nonzerop (cond
))
6703 /* Canonicalize the loop condition to the end. This means
6704 generating a branch to the loop condition. Reuse the
6705 continue label, if possible. */
6710 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
6711 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
6714 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
6715 SET_EXPR_LOCATION (t
, start_locus
);
6719 t
= build_and_jump (&blab
);
6720 exit
= build3 (COND_EXPR
, void_type_node
, cond
, exit
, t
);
6723 SET_EXPR_LOCATION (exit
, start_locus
);
6725 SET_EXPR_LOCATION (exit
, input_location
);
6734 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
6742 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
6746 c_finish_bc_stmt (tree
*label_p
, bool is_break
)
6748 tree label
= *label_p
;
6751 *label_p
= label
= create_artificial_label ();
6752 else if (TREE_CODE (label
) != LABEL_DECL
)
6755 error ("break statement not within loop or switch");
6757 error ("continue statement not within a loop");
6761 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
6764 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
6767 emit_side_effect_warnings (tree expr
)
6769 if (expr
== error_mark_node
)
6771 else if (!TREE_SIDE_EFFECTS (expr
))
6773 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
6774 warning ("%Hstatement with no effect",
6775 EXPR_HAS_LOCATION (expr
) ? EXPR_LOCUS (expr
) : &input_location
);
6777 else if (warn_unused_value
)
6778 warn_if_unused_value (expr
, input_location
);
6781 /* Process an expression as if it were a complete statement. Emit
6782 diagnostics, but do not call ADD_STMT. */
6785 c_process_expr_stmt (tree expr
)
6790 /* Do default conversion if safe and possibly important,
6791 in case within ({...}). */
6792 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
6793 && (flag_isoc99
|| lvalue_p (expr
)))
6794 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
6795 expr
= default_conversion (expr
);
6797 if (warn_sequence_point
)
6798 verify_sequence_points (expr
);
6800 if (TREE_TYPE (expr
) != error_mark_node
6801 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
6802 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
6803 error ("expression statement has incomplete type");
6805 /* If we're not processing a statement expression, warn about unused values.
6806 Warnings for statement expressions will be emitted later, once we figure
6807 out which is the result. */
6808 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
6809 && (extra_warnings
|| warn_unused_value
))
6810 emit_side_effect_warnings (expr
);
6812 /* If the expression is not of a type to which we cannot assign a line
6813 number, wrap the thing in a no-op NOP_EXPR. */
6814 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
6815 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
6818 SET_EXPR_LOCATION (expr
, input_location
);
6823 /* Emit an expression as a statement. */
6826 c_finish_expr_stmt (tree expr
)
6829 return add_stmt (c_process_expr_stmt (expr
));
6834 /* Do the opposite and emit a statement as an expression. To begin,
6835 create a new binding level and return it. */
6838 c_begin_stmt_expr (void)
6842 /* We must force a BLOCK for this level so that, if it is not expanded
6843 later, there is a way to turn off the entire subtree of blocks that
6844 are contained in it. */
6846 ret
= c_begin_compound_stmt (true);
6848 /* Mark the current statement list as belonging to a statement list. */
6849 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
6855 c_finish_stmt_expr (tree body
)
6857 tree last
, type
, tmp
, val
;
6860 body
= c_end_compound_stmt (body
, true);
6862 /* Locate the last statement in BODY. See c_end_compound_stmt
6863 about always returning a BIND_EXPR. */
6864 last_p
= &BIND_EXPR_BODY (body
);
6865 last
= BIND_EXPR_BODY (body
);
6868 if (TREE_CODE (last
) == STATEMENT_LIST
)
6870 tree_stmt_iterator i
;
6872 /* This can happen with degenerate cases like ({ }). No value. */
6873 if (!TREE_SIDE_EFFECTS (last
))
6876 /* If we're supposed to generate side effects warnings, process
6877 all of the statements except the last. */
6878 if (extra_warnings
|| warn_unused_value
)
6880 for (i
= tsi_start (last
); !tsi_one_before_end_p (i
); tsi_next (&i
))
6881 emit_side_effect_warnings (tsi_stmt (i
));
6884 i
= tsi_last (last
);
6885 last_p
= tsi_stmt_ptr (i
);
6889 /* If the end of the list is exception related, then the list was split
6890 by a call to push_cleanup. Continue searching. */
6891 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
6892 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
6894 last_p
= &TREE_OPERAND (last
, 0);
6896 goto continue_searching
;
6899 /* In the case that the BIND_EXPR is not necessary, return the
6900 expression out from inside it. */
6901 if (last
== error_mark_node
6902 || (last
== BIND_EXPR_BODY (body
)
6903 && BIND_EXPR_VARS (body
) == NULL
))
6906 /* Extract the type of said expression. */
6907 type
= TREE_TYPE (last
);
6909 /* If we're not returning a value at all, then the BIND_EXPR that
6910 we already have is a fine expression to return. */
6911 if (!type
|| VOID_TYPE_P (type
))
6914 /* Now that we've located the expression containing the value, it seems
6915 silly to make voidify_wrapper_expr repeat the process. Create a
6916 temporary of the appropriate type and stick it in a TARGET_EXPR. */
6917 tmp
= create_tmp_var_raw (type
, NULL
);
6919 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
6920 tree_expr_nonnegative_p giving up immediately. */
6922 if (TREE_CODE (val
) == NOP_EXPR
6923 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
6924 val
= TREE_OPERAND (val
, 0);
6926 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
6927 SET_EXPR_LOCUS (*last_p
, EXPR_LOCUS (last
));
6929 return build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
6932 /* Begin and end compound statements. This is as simple as pushing
6933 and popping new statement lists from the tree. */
6936 c_begin_compound_stmt (bool do_scope
)
6938 tree stmt
= push_stmt_list ();
6945 c_end_compound_stmt (tree stmt
, bool do_scope
)
6951 if (c_dialect_objc ())
6952 objc_clear_super_receiver ();
6953 block
= pop_scope ();
6956 stmt
= pop_stmt_list (stmt
);
6957 stmt
= c_build_bind_expr (block
, stmt
);
6959 /* If this compound statement is nested immediately inside a statement
6960 expression, then force a BIND_EXPR to be created. Otherwise we'll
6961 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
6962 STATEMENT_LISTs merge, and thus we can lose track of what statement
6965 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
6966 && TREE_CODE (stmt
) != BIND_EXPR
)
6968 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
6969 TREE_SIDE_EFFECTS (stmt
) = 1;
6975 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
6976 when the current scope is exited. EH_ONLY is true when this is not
6977 meant to apply to normal control flow transfer. */
6980 push_cleanup (tree
ARG_UNUSED (decl
), tree cleanup
, bool eh_only
)
6982 enum tree_code code
;
6986 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
6987 stmt
= build_stmt (code
, NULL
, cleanup
);
6989 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
6990 list
= push_stmt_list ();
6991 TREE_OPERAND (stmt
, 0) = list
;
6992 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
6995 /* Build a binary-operation expression without default conversions.
6996 CODE is the kind of expression to build.
6997 This function differs from `build' in several ways:
6998 the data type of the result is computed and recorded in it,
6999 warnings are generated if arg data types are invalid,
7000 special handling for addition and subtraction of pointers is known,
7001 and some optimization is done (operations on narrow ints
7002 are done in the narrower type when that gives the same result).
7003 Constant folding is also done before the result is returned.
7005 Note that the operands will never have enumeral types, or function
7006 or array types, because either they will have the default conversions
7007 performed or they have both just been converted to some other type in which
7008 the arithmetic is to be done. */
7011 build_binary_op (enum tree_code code
, tree orig_op0
, tree orig_op1
,
7015 enum tree_code code0
, code1
;
7018 /* Expression code to give to the expression when it is built.
7019 Normally this is CODE, which is what the caller asked for,
7020 but in some special cases we change it. */
7021 enum tree_code resultcode
= code
;
7023 /* Data type in which the computation is to be performed.
7024 In the simplest cases this is the common type of the arguments. */
7025 tree result_type
= NULL
;
7027 /* Nonzero means operands have already been type-converted
7028 in whatever way is necessary.
7029 Zero means they need to be converted to RESULT_TYPE. */
7032 /* Nonzero means create the expression with this type, rather than
7034 tree build_type
= 0;
7036 /* Nonzero means after finally constructing the expression
7037 convert it to this type. */
7038 tree final_type
= 0;
7040 /* Nonzero if this is an operation like MIN or MAX which can
7041 safely be computed in short if both args are promoted shorts.
7042 Also implies COMMON.
7043 -1 indicates a bitwise operation; this makes a difference
7044 in the exact conditions for when it is safe to do the operation
7045 in a narrower mode. */
7048 /* Nonzero if this is a comparison operation;
7049 if both args are promoted shorts, compare the original shorts.
7050 Also implies COMMON. */
7051 int short_compare
= 0;
7053 /* Nonzero if this is a right-shift operation, which can be computed on the
7054 original short and then promoted if the operand is a promoted short. */
7055 int short_shift
= 0;
7057 /* Nonzero means set RESULT_TYPE to the common type of the args. */
7062 op0
= default_conversion (orig_op0
);
7063 op1
= default_conversion (orig_op1
);
7071 type0
= TREE_TYPE (op0
);
7072 type1
= TREE_TYPE (op1
);
7074 /* The expression codes of the data types of the arguments tell us
7075 whether the arguments are integers, floating, pointers, etc. */
7076 code0
= TREE_CODE (type0
);
7077 code1
= TREE_CODE (type1
);
7079 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
7080 STRIP_TYPE_NOPS (op0
);
7081 STRIP_TYPE_NOPS (op1
);
7083 /* If an error was already reported for one of the arguments,
7084 avoid reporting another error. */
7086 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
7087 return error_mark_node
;
7092 /* Handle the pointer + int case. */
7093 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7094 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
7095 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
7096 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
7102 /* Subtraction of two similar pointers.
7103 We must subtract them as integers, then divide by object size. */
7104 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
7105 && comp_target_types (type0
, type1
, 1))
7106 return pointer_diff (op0
, op1
);
7107 /* Handle pointer minus int. Just like pointer plus int. */
7108 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7109 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
7118 case TRUNC_DIV_EXPR
:
7120 case FLOOR_DIV_EXPR
:
7121 case ROUND_DIV_EXPR
:
7122 case EXACT_DIV_EXPR
:
7123 /* Floating point division by zero is a legitimate way to obtain
7124 infinities and NaNs. */
7125 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
7126 warning ("division by zero");
7128 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
7129 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
7130 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
7131 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
7133 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
7134 code0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
7135 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
7136 code1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
7138 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
7139 resultcode
= RDIV_EXPR
;
7141 /* Although it would be tempting to shorten always here, that
7142 loses on some targets, since the modulo instruction is
7143 undefined if the quotient can't be represented in the
7144 computation mode. We shorten only if unsigned or if
7145 dividing by something we know != -1. */
7146 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
7147 || (TREE_CODE (op1
) == INTEGER_CST
7148 && !integer_all_onesp (op1
)));
7156 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7158 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
7162 case TRUNC_MOD_EXPR
:
7163 case FLOOR_MOD_EXPR
:
7164 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
7165 warning ("division by zero");
7167 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7169 /* Although it would be tempting to shorten always here, that loses
7170 on some targets, since the modulo instruction is undefined if the
7171 quotient can't be represented in the computation mode. We shorten
7172 only if unsigned or if dividing by something we know != -1. */
7173 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
7174 || (TREE_CODE (op1
) == INTEGER_CST
7175 && !integer_all_onesp (op1
)));
7180 case TRUTH_ANDIF_EXPR
:
7181 case TRUTH_ORIF_EXPR
:
7182 case TRUTH_AND_EXPR
:
7184 case TRUTH_XOR_EXPR
:
7185 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
7186 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
7187 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
7188 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
7190 /* Result of these operations is always an int,
7191 but that does not mean the operands should be
7192 converted to ints! */
7193 result_type
= integer_type_node
;
7194 op0
= lang_hooks
.truthvalue_conversion (op0
);
7195 op1
= lang_hooks
.truthvalue_conversion (op1
);
7200 /* Shift operations: result has same type as first operand;
7201 always convert second operand to int.
7202 Also set SHORT_SHIFT if shifting rightward. */
7205 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7207 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
7209 if (tree_int_cst_sgn (op1
) < 0)
7210 warning ("right shift count is negative");
7213 if (!integer_zerop (op1
))
7216 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
7217 warning ("right shift count >= width of type");
7221 /* Use the type of the value to be shifted. */
7222 result_type
= type0
;
7223 /* Convert the shift-count to an integer, regardless of size
7224 of value being shifted. */
7225 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
7226 op1
= convert (integer_type_node
, op1
);
7227 /* Avoid converting op1 to result_type later. */
7233 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7235 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
7237 if (tree_int_cst_sgn (op1
) < 0)
7238 warning ("left shift count is negative");
7240 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
7241 warning ("left shift count >= width of type");
7244 /* Use the type of the value to be shifted. */
7245 result_type
= type0
;
7246 /* Convert the shift-count to an integer, regardless of size
7247 of value being shifted. */
7248 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
7249 op1
= convert (integer_type_node
, op1
);
7250 /* Avoid converting op1 to result_type later. */
7257 if (warn_float_equal
&& (code0
== REAL_TYPE
|| code1
== REAL_TYPE
))
7258 warning ("comparing floating point with == or != is unsafe");
7259 /* Result of comparison is always int,
7260 but don't convert the args to int! */
7261 build_type
= integer_type_node
;
7262 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
7263 || code0
== COMPLEX_TYPE
)
7264 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
7265 || code1
== COMPLEX_TYPE
))
7267 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
7269 tree tt0
= TREE_TYPE (type0
);
7270 tree tt1
= TREE_TYPE (type1
);
7271 /* Anything compares with void *. void * compares with anything.
7272 Otherwise, the targets must be compatible
7273 and both must be object or both incomplete. */
7274 if (comp_target_types (type0
, type1
, 1))
7275 result_type
= common_pointer_type (type0
, type1
);
7276 else if (VOID_TYPE_P (tt0
))
7278 /* op0 != orig_op0 detects the case of something
7279 whose value is 0 but which isn't a valid null ptr const. */
7280 if (pedantic
&& (!integer_zerop (op0
) || op0
!= orig_op0
)
7281 && TREE_CODE (tt1
) == FUNCTION_TYPE
)
7282 pedwarn ("ISO C forbids comparison of %<void *%>"
7283 " with function pointer");
7285 else if (VOID_TYPE_P (tt1
))
7287 if (pedantic
&& (!integer_zerop (op1
) || op1
!= orig_op1
)
7288 && TREE_CODE (tt0
) == FUNCTION_TYPE
)
7289 pedwarn ("ISO C forbids comparison of %<void *%>"
7290 " with function pointer");
7293 pedwarn ("comparison of distinct pointer types lacks a cast");
7295 if (result_type
== NULL_TREE
)
7296 result_type
= ptr_type_node
;
7298 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
7299 && integer_zerop (op1
))
7300 result_type
= type0
;
7301 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
7302 && integer_zerop (op0
))
7303 result_type
= type1
;
7304 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7306 result_type
= type0
;
7307 pedwarn ("comparison between pointer and integer");
7309 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
7311 result_type
= type1
;
7312 pedwarn ("comparison between pointer and integer");
7320 build_type
= integer_type_node
;
7321 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
7322 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
7324 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
7326 if (comp_target_types (type0
, type1
, 1))
7328 result_type
= common_pointer_type (type0
, type1
);
7329 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
7330 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
7331 pedwarn ("comparison of complete and incomplete pointers");
7333 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
7334 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7338 result_type
= ptr_type_node
;
7339 pedwarn ("comparison of distinct pointer types lacks a cast");
7342 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
7343 && integer_zerop (op1
))
7345 result_type
= type0
;
7346 if (pedantic
|| extra_warnings
)
7347 pedwarn ("ordered comparison of pointer with integer zero");
7349 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
7350 && integer_zerop (op0
))
7352 result_type
= type1
;
7354 pedwarn ("ordered comparison of pointer with integer zero");
7356 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7358 result_type
= type0
;
7359 pedwarn ("comparison between pointer and integer");
7361 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
7363 result_type
= type1
;
7364 pedwarn ("comparison between pointer and integer");
7372 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
7373 return error_mark_node
;
7375 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
7376 || code0
== VECTOR_TYPE
)
7378 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
7379 || code1
== VECTOR_TYPE
))
7381 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
7383 if (shorten
|| common
|| short_compare
)
7384 result_type
= common_type (type0
, type1
);
7386 /* For certain operations (which identify themselves by shorten != 0)
7387 if both args were extended from the same smaller type,
7388 do the arithmetic in that type and then extend.
7390 shorten !=0 and !=1 indicates a bitwise operation.
7391 For them, this optimization is safe only if
7392 both args are zero-extended or both are sign-extended.
7393 Otherwise, we might change the result.
7394 Eg, (short)-1 | (unsigned short)-1 is (int)-1
7395 but calculated in (unsigned short) it would be (unsigned short)-1. */
7397 if (shorten
&& none_complex
)
7399 int unsigned0
, unsigned1
;
7400 tree arg0
= get_narrower (op0
, &unsigned0
);
7401 tree arg1
= get_narrower (op1
, &unsigned1
);
7402 /* UNS is 1 if the operation to be done is an unsigned one. */
7403 int uns
= TYPE_UNSIGNED (result_type
);
7406 final_type
= result_type
;
7408 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7409 but it *requires* conversion to FINAL_TYPE. */
7411 if ((TYPE_PRECISION (TREE_TYPE (op0
))
7412 == TYPE_PRECISION (TREE_TYPE (arg0
)))
7413 && TREE_TYPE (op0
) != final_type
)
7414 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
7415 if ((TYPE_PRECISION (TREE_TYPE (op1
))
7416 == TYPE_PRECISION (TREE_TYPE (arg1
)))
7417 && TREE_TYPE (op1
) != final_type
)
7418 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
7420 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
7422 /* For bitwise operations, signedness of nominal type
7423 does not matter. Consider only how operands were extended. */
7427 /* Note that in all three cases below we refrain from optimizing
7428 an unsigned operation on sign-extended args.
7429 That would not be valid. */
7431 /* Both args variable: if both extended in same way
7432 from same width, do it in that width.
7433 Do it unsigned if args were zero-extended. */
7434 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
7435 < TYPE_PRECISION (result_type
))
7436 && (TYPE_PRECISION (TREE_TYPE (arg1
))
7437 == TYPE_PRECISION (TREE_TYPE (arg0
)))
7438 && unsigned0
== unsigned1
7439 && (unsigned0
|| !uns
))
7441 = c_common_signed_or_unsigned_type
7442 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
7443 else if (TREE_CODE (arg0
) == INTEGER_CST
7444 && (unsigned1
|| !uns
)
7445 && (TYPE_PRECISION (TREE_TYPE (arg1
))
7446 < TYPE_PRECISION (result_type
))
7448 = c_common_signed_or_unsigned_type (unsigned1
,
7450 int_fits_type_p (arg0
, type
)))
7452 else if (TREE_CODE (arg1
) == INTEGER_CST
7453 && (unsigned0
|| !uns
)
7454 && (TYPE_PRECISION (TREE_TYPE (arg0
))
7455 < TYPE_PRECISION (result_type
))
7457 = c_common_signed_or_unsigned_type (unsigned0
,
7459 int_fits_type_p (arg1
, type
)))
7463 /* Shifts can be shortened if shifting right. */
7468 tree arg0
= get_narrower (op0
, &unsigned_arg
);
7470 final_type
= result_type
;
7472 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
7473 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
7475 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
7476 /* We can shorten only if the shift count is less than the
7477 number of bits in the smaller type size. */
7478 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
7479 /* We cannot drop an unsigned shift after sign-extension. */
7480 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
7482 /* Do an unsigned shift if the operand was zero-extended. */
7484 = c_common_signed_or_unsigned_type (unsigned_arg
,
7486 /* Convert value-to-be-shifted to that type. */
7487 if (TREE_TYPE (op0
) != result_type
)
7488 op0
= convert (result_type
, op0
);
7493 /* Comparison operations are shortened too but differently.
7494 They identify themselves by setting short_compare = 1. */
7498 /* Don't write &op0, etc., because that would prevent op0
7499 from being kept in a register.
7500 Instead, make copies of the our local variables and
7501 pass the copies by reference, then copy them back afterward. */
7502 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
7503 enum tree_code xresultcode
= resultcode
;
7505 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
7510 op0
= xop0
, op1
= xop1
;
7512 resultcode
= xresultcode
;
7514 if (warn_sign_compare
&& skip_evaluation
== 0)
7516 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
7517 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
7518 int unsignedp0
, unsignedp1
;
7519 tree primop0
= get_narrower (op0
, &unsignedp0
);
7520 tree primop1
= get_narrower (op1
, &unsignedp1
);
7524 STRIP_TYPE_NOPS (xop0
);
7525 STRIP_TYPE_NOPS (xop1
);
7527 /* Give warnings for comparisons between signed and unsigned
7528 quantities that may fail.
7530 Do the checking based on the original operand trees, so that
7531 casts will be considered, but default promotions won't be.
7533 Do not warn if the comparison is being done in a signed type,
7534 since the signed type will only be chosen if it can represent
7535 all the values of the unsigned type. */
7536 if (!TYPE_UNSIGNED (result_type
))
7538 /* Do not warn if both operands are the same signedness. */
7539 else if (op0_signed
== op1_signed
)
7546 sop
= xop0
, uop
= xop1
;
7548 sop
= xop1
, uop
= xop0
;
7550 /* Do not warn if the signed quantity is an
7551 unsuffixed integer literal (or some static
7552 constant expression involving such literals or a
7553 conditional expression involving such literals)
7554 and it is non-negative. */
7555 if (tree_expr_nonnegative_p (sop
))
7557 /* Do not warn if the comparison is an equality operation,
7558 the unsigned quantity is an integral constant, and it
7559 would fit in the result if the result were signed. */
7560 else if (TREE_CODE (uop
) == INTEGER_CST
7561 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
7563 (uop
, c_common_signed_type (result_type
)))
7565 /* Do not warn if the unsigned quantity is an enumeration
7566 constant and its maximum value would fit in the result
7567 if the result were signed. */
7568 else if (TREE_CODE (uop
) == INTEGER_CST
7569 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
7571 (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
7572 c_common_signed_type (result_type
)))
7575 warning ("comparison between signed and unsigned");
7578 /* Warn if two unsigned values are being compared in a size
7579 larger than their original size, and one (and only one) is the
7580 result of a `~' operator. This comparison will always fail.
7582 Also warn if one operand is a constant, and the constant
7583 does not have all bits set that are set in the ~ operand
7584 when it is extended. */
7586 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
7587 != (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
7589 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
7590 primop0
= get_narrower (TREE_OPERAND (primop0
, 0),
7593 primop1
= get_narrower (TREE_OPERAND (primop1
, 0),
7596 if (host_integerp (primop0
, 0) || host_integerp (primop1
, 0))
7599 HOST_WIDE_INT constant
, mask
;
7600 int unsignedp
, bits
;
7602 if (host_integerp (primop0
, 0))
7605 unsignedp
= unsignedp1
;
7606 constant
= tree_low_cst (primop0
, 0);
7611 unsignedp
= unsignedp0
;
7612 constant
= tree_low_cst (primop1
, 0);
7615 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
7616 if (bits
< TYPE_PRECISION (result_type
)
7617 && bits
< HOST_BITS_PER_WIDE_INT
&& unsignedp
)
7619 mask
= (~(HOST_WIDE_INT
) 0) << bits
;
7620 if ((mask
& constant
) != mask
)
7621 warning ("comparison of promoted ~unsigned with constant");
7624 else if (unsignedp0
&& unsignedp1
7625 && (TYPE_PRECISION (TREE_TYPE (primop0
))
7626 < TYPE_PRECISION (result_type
))
7627 && (TYPE_PRECISION (TREE_TYPE (primop1
))
7628 < TYPE_PRECISION (result_type
)))
7629 warning ("comparison of promoted ~unsigned with unsigned");
7635 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7636 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7637 Then the expression will be built.
7638 It will be given type FINAL_TYPE if that is nonzero;
7639 otherwise, it will be given type RESULT_TYPE. */
7643 binary_op_error (code
);
7644 return error_mark_node
;
7649 if (TREE_TYPE (op0
) != result_type
)
7650 op0
= convert (result_type
, op0
);
7651 if (TREE_TYPE (op1
) != result_type
)
7652 op1
= convert (result_type
, op1
);
7654 /* This can happen if one operand has a vector type, and the other
7655 has a different type. */
7656 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
7657 return error_mark_node
;
7660 if (build_type
== NULL_TREE
)
7661 build_type
= result_type
;
7664 tree result
= build2 (resultcode
, build_type
, op0
, op1
);
7666 /* Treat expressions in initializers specially as they can't trap. */
7667 result
= require_constant_value
? fold_initializer (result
)
7670 if (final_type
!= 0)
7671 result
= convert (final_type
, result
);