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"
46 #include "tree-flow.h"
48 /* Possible cases of implicit bad conversions. Used to select
49 diagnostic messages in convert_for_assignment. */
58 /* The level of nesting inside "__alignof__". */
61 /* The level of nesting inside "sizeof". */
64 /* The level of nesting inside "typeof". */
67 /* Nonzero if we've already printed a "missing braces around initializer"
68 message within this initializer. */
69 static int missing_braces_mentioned
;
71 static int require_constant_value
;
72 static int require_constant_elements
;
74 static tree
qualify_type (tree
, tree
);
75 static int tagged_types_tu_compatible_p (tree
, tree
);
76 static int comp_target_types (tree
, tree
, int);
77 static int function_types_compatible_p (tree
, tree
);
78 static int type_lists_compatible_p (tree
, tree
);
79 static tree
decl_constant_value_for_broken_optimization (tree
);
80 static tree
default_function_array_conversion (tree
);
81 static tree
lookup_field (tree
, tree
);
82 static tree
convert_arguments (tree
, tree
, tree
, tree
);
83 static tree
pointer_diff (tree
, tree
);
84 static tree
convert_for_assignment (tree
, tree
, enum impl_conv
, tree
, tree
,
86 static tree
valid_compound_expr_initializer (tree
, tree
);
87 static void push_string (const char *);
88 static void push_member_name (tree
);
89 static void push_array_bounds (int);
90 static int spelling_length (void);
91 static char *print_spelling (char *);
92 static void warning_init (const char *);
93 static tree
digest_init (tree
, tree
, bool, int);
94 static void output_init_element (tree
, bool, tree
, tree
, int);
95 static void output_pending_init_elements (int);
96 static int set_designator (int);
97 static void push_range_stack (tree
);
98 static void add_pending_init (tree
, tree
);
99 static void set_nonincremental_init (void);
100 static void set_nonincremental_init_from_string (tree
);
101 static tree
find_init_member (tree
);
102 static void readonly_error (tree
, enum lvalue_use
);
103 static void record_maybe_used_decl (tree
);
105 /* Do `exp = require_complete_type (exp);' to make sure exp
106 does not have an incomplete type. (That includes void types.) */
109 require_complete_type (tree value
)
111 tree type
= TREE_TYPE (value
);
113 if (value
== error_mark_node
|| type
== error_mark_node
)
114 return error_mark_node
;
116 /* First, detect a valid value with a complete type. */
117 if (COMPLETE_TYPE_P (type
))
120 c_incomplete_type_error (value
, type
);
121 return error_mark_node
;
124 /* Print an error message for invalid use of an incomplete type.
125 VALUE is the expression that was used (or 0 if that isn't known)
126 and TYPE is the type that was invalid. */
129 c_incomplete_type_error (tree value
, tree type
)
131 const char *type_code_string
;
133 /* Avoid duplicate error message. */
134 if (TREE_CODE (type
) == ERROR_MARK
)
137 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
138 || TREE_CODE (value
) == PARM_DECL
))
139 error ("%qs has an incomplete type",
140 IDENTIFIER_POINTER (DECL_NAME (value
)));
144 /* We must print an error message. Be clever about what it says. */
146 switch (TREE_CODE (type
))
149 type_code_string
= "struct";
153 type_code_string
= "union";
157 type_code_string
= "enum";
161 error ("invalid use of void expression");
165 if (TYPE_DOMAIN (type
))
167 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL
)
169 error ("invalid use of flexible array member");
172 type
= TREE_TYPE (type
);
175 error ("invalid use of array with unspecified bounds");
182 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
183 error ("invalid use of undefined type %<%s %s%>",
184 type_code_string
, IDENTIFIER_POINTER (TYPE_NAME (type
)));
186 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
187 error ("invalid use of incomplete typedef %qs",
188 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
))));
192 /* Given a type, apply default promotions wrt unnamed function
193 arguments and return the new type. */
196 c_type_promotes_to (tree type
)
198 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
199 return double_type_node
;
201 if (c_promoting_integer_type_p (type
))
203 /* Preserve unsignedness if not really getting any wider. */
204 if (TYPE_UNSIGNED (type
)
205 && (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
206 return unsigned_type_node
;
207 return integer_type_node
;
213 /* Return a variant of TYPE which has all the type qualifiers of LIKE
214 as well as those of TYPE. */
217 qualify_type (tree type
, tree like
)
219 return c_build_qualified_type (type
,
220 TYPE_QUALS (type
) | TYPE_QUALS (like
));
223 /* Return the composite type of two compatible types.
225 We assume that comptypes has already been done and returned
226 nonzero; if that isn't so, this may crash. In particular, we
227 assume that qualifiers match. */
230 composite_type (tree t1
, tree t2
)
232 enum tree_code code1
;
233 enum tree_code code2
;
236 /* Save time if the two types are the same. */
238 if (t1
== t2
) return t1
;
240 /* If one type is nonsense, use the other. */
241 if (t1
== error_mark_node
)
243 if (t2
== error_mark_node
)
246 code1
= TREE_CODE (t1
);
247 code2
= TREE_CODE (t2
);
249 /* Merge the attributes. */
250 attributes
= targetm
.merge_type_attributes (t1
, t2
);
252 /* If one is an enumerated type and the other is the compatible
253 integer type, the composite type might be either of the two
254 (DR#013 question 3). For consistency, use the enumerated type as
255 the composite type. */
257 if (code1
== ENUMERAL_TYPE
&& code2
== INTEGER_TYPE
)
259 if (code2
== ENUMERAL_TYPE
&& code1
== INTEGER_TYPE
)
262 gcc_assert (code1
== code2
);
267 /* For two pointers, do this recursively on the target type. */
269 tree pointed_to_1
= TREE_TYPE (t1
);
270 tree pointed_to_2
= TREE_TYPE (t2
);
271 tree target
= composite_type (pointed_to_1
, pointed_to_2
);
272 t1
= build_pointer_type (target
);
273 t1
= build_type_attribute_variant (t1
, attributes
);
274 return qualify_type (t1
, t2
);
279 tree elt
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
283 /* We should not have any type quals on arrays at all. */
284 gcc_assert (!TYPE_QUALS (t1
) && !TYPE_QUALS (t2
));
286 /* Save space: see if the result is identical to one of the args. */
287 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
288 return build_type_attribute_variant (t1
, attributes
);
289 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
290 return build_type_attribute_variant (t2
, attributes
);
292 if (elt
== TREE_TYPE (t1
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
293 return build_type_attribute_variant (t1
, attributes
);
294 if (elt
== TREE_TYPE (t2
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
295 return build_type_attribute_variant (t2
, attributes
);
297 /* Merge the element types, and have a size if either arg has
298 one. We may have qualifiers on the element types. To set
299 up TYPE_MAIN_VARIANT correctly, we need to form the
300 composite of the unqualified types and add the qualifiers
302 quals
= TYPE_QUALS (strip_array_types (elt
));
303 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
304 t1
= build_array_type (unqual_elt
,
305 TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
306 t1
= c_build_qualified_type (t1
, quals
);
307 return build_type_attribute_variant (t1
, attributes
);
311 /* Function types: prefer the one that specified arg types.
312 If both do, merge the arg types. Also merge the return types. */
314 tree valtype
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
315 tree p1
= TYPE_ARG_TYPES (t1
);
316 tree p2
= TYPE_ARG_TYPES (t2
);
321 /* Save space: see if the result is identical to one of the args. */
322 if (valtype
== TREE_TYPE (t1
) && !TYPE_ARG_TYPES (t2
))
323 return build_type_attribute_variant (t1
, attributes
);
324 if (valtype
== TREE_TYPE (t2
) && !TYPE_ARG_TYPES (t1
))
325 return build_type_attribute_variant (t2
, attributes
);
327 /* Simple way if one arg fails to specify argument types. */
328 if (TYPE_ARG_TYPES (t1
) == 0)
330 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t2
));
331 t1
= build_type_attribute_variant (t1
, attributes
);
332 return qualify_type (t1
, t2
);
334 if (TYPE_ARG_TYPES (t2
) == 0)
336 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t1
));
337 t1
= build_type_attribute_variant (t1
, attributes
);
338 return qualify_type (t1
, t2
);
341 /* If both args specify argument types, we must merge the two
342 lists, argument by argument. */
343 /* Tell global_bindings_p to return false so that variable_size
344 doesn't abort on VLAs in parameter types. */
345 c_override_global_bindings_to_false
= true;
347 len
= list_length (p1
);
350 for (i
= 0; i
< len
; i
++)
351 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
356 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
))
358 /* A null type means arg type is not specified.
359 Take whatever the other function type has. */
360 if (TREE_VALUE (p1
) == 0)
362 TREE_VALUE (n
) = TREE_VALUE (p2
);
365 if (TREE_VALUE (p2
) == 0)
367 TREE_VALUE (n
) = TREE_VALUE (p1
);
371 /* Given wait (union {union wait *u; int *i} *)
372 and wait (union wait *),
373 prefer union wait * as type of parm. */
374 if (TREE_CODE (TREE_VALUE (p1
)) == UNION_TYPE
375 && TREE_VALUE (p1
) != TREE_VALUE (p2
))
378 tree mv2
= TREE_VALUE (p2
);
379 if (mv2
&& mv2
!= error_mark_node
380 && TREE_CODE (mv2
) != ARRAY_TYPE
)
381 mv2
= TYPE_MAIN_VARIANT (mv2
);
382 for (memb
= TYPE_FIELDS (TREE_VALUE (p1
));
383 memb
; memb
= TREE_CHAIN (memb
))
385 tree mv3
= TREE_TYPE (memb
);
386 if (mv3
&& mv3
!= error_mark_node
387 && TREE_CODE (mv3
) != ARRAY_TYPE
)
388 mv3
= TYPE_MAIN_VARIANT (mv3
);
389 if (comptypes (mv3
, mv2
))
391 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
394 pedwarn ("function types not truly compatible in ISO C");
399 if (TREE_CODE (TREE_VALUE (p2
)) == UNION_TYPE
400 && TREE_VALUE (p2
) != TREE_VALUE (p1
))
403 tree mv1
= TREE_VALUE (p1
);
404 if (mv1
&& mv1
!= error_mark_node
405 && TREE_CODE (mv1
) != ARRAY_TYPE
)
406 mv1
= TYPE_MAIN_VARIANT (mv1
);
407 for (memb
= TYPE_FIELDS (TREE_VALUE (p2
));
408 memb
; memb
= TREE_CHAIN (memb
))
410 tree mv3
= TREE_TYPE (memb
);
411 if (mv3
&& mv3
!= error_mark_node
412 && TREE_CODE (mv3
) != ARRAY_TYPE
)
413 mv3
= TYPE_MAIN_VARIANT (mv3
);
414 if (comptypes (mv3
, mv1
))
416 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
419 pedwarn ("function types not truly compatible in ISO C");
424 TREE_VALUE (n
) = composite_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
428 c_override_global_bindings_to_false
= false;
429 t1
= build_function_type (valtype
, newargs
);
430 t1
= qualify_type (t1
, t2
);
431 /* ... falls through ... */
435 return build_type_attribute_variant (t1
, attributes
);
440 /* Return the type of a conditional expression between pointers to
441 possibly differently qualified versions of compatible types.
443 We assume that comp_target_types has already been done and returned
444 nonzero; if that isn't so, this may crash. */
447 common_pointer_type (tree t1
, tree t2
)
450 tree pointed_to_1
, mv1
;
451 tree pointed_to_2
, mv2
;
454 /* Save time if the two types are the same. */
456 if (t1
== t2
) return t1
;
458 /* If one type is nonsense, use the other. */
459 if (t1
== error_mark_node
)
461 if (t2
== error_mark_node
)
464 gcc_assert (TREE_CODE (t1
) == POINTER_TYPE
465 && TREE_CODE (t2
) == POINTER_TYPE
);
467 /* Merge the attributes. */
468 attributes
= targetm
.merge_type_attributes (t1
, t2
);
470 /* Find the composite type of the target types, and combine the
471 qualifiers of the two types' targets. Do not lose qualifiers on
472 array element types by taking the TYPE_MAIN_VARIANT. */
473 mv1
= pointed_to_1
= TREE_TYPE (t1
);
474 mv2
= pointed_to_2
= TREE_TYPE (t2
);
475 if (TREE_CODE (mv1
) != ARRAY_TYPE
)
476 mv1
= TYPE_MAIN_VARIANT (pointed_to_1
);
477 if (TREE_CODE (mv2
) != ARRAY_TYPE
)
478 mv2
= TYPE_MAIN_VARIANT (pointed_to_2
);
479 target
= composite_type (mv1
, mv2
);
480 t1
= build_pointer_type (c_build_qualified_type
482 TYPE_QUALS (pointed_to_1
) |
483 TYPE_QUALS (pointed_to_2
)));
484 return build_type_attribute_variant (t1
, attributes
);
487 /* Return the common type for two arithmetic types under the usual
488 arithmetic conversions. The default conversions have already been
489 applied, and enumerated types converted to their compatible integer
490 types. The resulting type is unqualified and has no attributes.
492 This is the type for the result of most arithmetic operations
493 if the operands have the given two types. */
496 c_common_type (tree t1
, tree t2
)
498 enum tree_code code1
;
499 enum tree_code code2
;
501 /* If one type is nonsense, use the other. */
502 if (t1
== error_mark_node
)
504 if (t2
== error_mark_node
)
507 if (TYPE_QUALS (t1
) != TYPE_UNQUALIFIED
)
508 t1
= TYPE_MAIN_VARIANT (t1
);
510 if (TYPE_QUALS (t2
) != TYPE_UNQUALIFIED
)
511 t2
= TYPE_MAIN_VARIANT (t2
);
513 if (TYPE_ATTRIBUTES (t1
) != NULL_TREE
)
514 t1
= build_type_attribute_variant (t1
, NULL_TREE
);
516 if (TYPE_ATTRIBUTES (t2
) != NULL_TREE
)
517 t2
= build_type_attribute_variant (t2
, NULL_TREE
);
519 /* Save time if the two types are the same. */
521 if (t1
== t2
) return t1
;
523 code1
= TREE_CODE (t1
);
524 code2
= TREE_CODE (t2
);
526 gcc_assert (code1
== VECTOR_TYPE
|| code1
== COMPLEX_TYPE
527 || code1
== REAL_TYPE
|| code1
== INTEGER_TYPE
);
528 gcc_assert (code2
== VECTOR_TYPE
|| code2
== COMPLEX_TYPE
529 || code2
== REAL_TYPE
|| code2
== INTEGER_TYPE
);
531 /* If one type is a vector type, return that type. (How the usual
532 arithmetic conversions apply to the vector types extension is not
533 precisely specified.) */
534 if (code1
== VECTOR_TYPE
)
537 if (code2
== VECTOR_TYPE
)
540 /* If one type is complex, form the common type of the non-complex
541 components, then make that complex. Use T1 or T2 if it is the
543 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
545 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
546 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
547 tree subtype
= c_common_type (subtype1
, subtype2
);
549 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
551 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
554 return build_complex_type (subtype
);
557 /* If only one is real, use it as the result. */
559 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
562 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
565 /* Both real or both integers; use the one with greater precision. */
567 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
569 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
572 /* Same precision. Prefer long longs to longs to ints when the
573 same precision, following the C99 rules on integer type rank
574 (which are equivalent to the C90 rules for C90 types). */
576 if (TYPE_MAIN_VARIANT (t1
) == long_long_unsigned_type_node
577 || TYPE_MAIN_VARIANT (t2
) == long_long_unsigned_type_node
)
578 return long_long_unsigned_type_node
;
580 if (TYPE_MAIN_VARIANT (t1
) == long_long_integer_type_node
581 || TYPE_MAIN_VARIANT (t2
) == long_long_integer_type_node
)
583 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
584 return long_long_unsigned_type_node
;
586 return long_long_integer_type_node
;
589 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
590 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
591 return long_unsigned_type_node
;
593 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
594 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
596 /* But preserve unsignedness from the other type,
597 since long cannot hold all the values of an unsigned int. */
598 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
599 return long_unsigned_type_node
;
601 return long_integer_type_node
;
604 /* Likewise, prefer long double to double even if same size. */
605 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
606 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
607 return long_double_type_node
;
609 /* Otherwise prefer the unsigned one. */
611 if (TYPE_UNSIGNED (t1
))
617 /* Wrapper around c_common_type that is used by c-common.c. ENUMERAL_TYPEs
618 are allowed here and are converted to their compatible integer types. */
620 common_type (tree t1
, tree t2
)
622 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
623 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), 1);
624 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
625 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), 1);
626 return c_common_type (t1
, t2
);
629 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
630 or various other operations. Return 2 if they are compatible
631 but a warning may be needed if you use them together. */
634 comptypes (tree type1
, tree type2
)
640 /* Suppress errors caused by previously reported errors. */
642 if (t1
== t2
|| !t1
|| !t2
643 || TREE_CODE (t1
) == ERROR_MARK
|| TREE_CODE (t2
) == ERROR_MARK
)
646 /* If either type is the internal version of sizetype, return the
648 if (TREE_CODE (t1
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t1
)
649 && TYPE_ORIG_SIZE_TYPE (t1
))
650 t1
= TYPE_ORIG_SIZE_TYPE (t1
);
652 if (TREE_CODE (t2
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t2
)
653 && TYPE_ORIG_SIZE_TYPE (t2
))
654 t2
= TYPE_ORIG_SIZE_TYPE (t2
);
657 /* Enumerated types are compatible with integer types, but this is
658 not transitive: two enumerated types in the same translation unit
659 are compatible with each other only if they are the same type. */
661 if (TREE_CODE (t1
) == ENUMERAL_TYPE
&& TREE_CODE (t2
) != ENUMERAL_TYPE
)
662 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), TYPE_UNSIGNED (t1
));
663 else if (TREE_CODE (t2
) == ENUMERAL_TYPE
&& TREE_CODE (t1
) != ENUMERAL_TYPE
)
664 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), TYPE_UNSIGNED (t2
));
669 /* Different classes of types can't be compatible. */
671 if (TREE_CODE (t1
) != TREE_CODE (t2
))
674 /* Qualifiers must match. C99 6.7.3p9 */
676 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
679 /* Allow for two different type nodes which have essentially the same
680 definition. Note that we already checked for equality of the type
681 qualifiers (just above). */
683 if (TREE_CODE (t1
) != ARRAY_TYPE
684 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
687 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
688 if (!(attrval
= targetm
.comp_type_attributes (t1
, t2
)))
691 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
694 switch (TREE_CODE (t1
))
697 /* We must give ObjC the first crack at comparing pointers, since
698 protocol qualifiers may be involved. */
699 if (c_dialect_objc () && (val
= objc_comptypes (t1
, t2
, 0)) >= 0)
701 /* Do not remove mode or aliasing information. */
702 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
703 || TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
))
705 val
= (TREE_TYPE (t1
) == TREE_TYPE (t2
)
706 ? 1 : comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
)));
710 val
= function_types_compatible_p (t1
, t2
);
715 tree d1
= TYPE_DOMAIN (t1
);
716 tree d2
= TYPE_DOMAIN (t2
);
717 bool d1_variable
, d2_variable
;
718 bool d1_zero
, d2_zero
;
721 /* Target types must match incl. qualifiers. */
722 if (TREE_TYPE (t1
) != TREE_TYPE (t2
)
723 && 0 == (val
= comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
))))
726 /* Sizes must match unless one is missing or variable. */
727 if (d1
== 0 || d2
== 0 || d1
== d2
)
730 d1_zero
= !TYPE_MAX_VALUE (d1
);
731 d2_zero
= !TYPE_MAX_VALUE (d2
);
733 d1_variable
= (!d1_zero
734 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
735 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
736 d2_variable
= (!d2_zero
737 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
738 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
740 if (d1_variable
|| d2_variable
)
742 if (d1_zero
&& d2_zero
)
744 if (d1_zero
|| d2_zero
745 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
))
746 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1
), TYPE_MAX_VALUE (d2
)))
753 /* We are dealing with two distinct structs. In assorted Objective-C
754 corner cases, however, these can still be deemed equivalent. */
755 if (c_dialect_objc () && objc_comptypes (t1
, t2
, 0) == 1)
760 if (val
!= 1 && !same_translation_unit_p (t1
, t2
))
761 val
= tagged_types_tu_compatible_p (t1
, t2
);
765 val
= TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
766 && comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
));
772 return attrval
== 2 && val
== 1 ? 2 : val
;
775 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
776 ignoring their qualifiers. REFLEXIVE is only used by ObjC - set it
777 to 1 or 0 depending if the check of the pointer types is meant to
778 be reflexive or not (typically, assignments are not reflexive,
779 while comparisons are reflexive).
783 comp_target_types (tree ttl
, tree ttr
, int reflexive
)
788 /* Give objc_comptypes a crack at letting these types through. */
789 if ((val
= objc_comptypes (ttl
, ttr
, reflexive
)) >= 0)
792 /* Do not lose qualifiers on element types of array types that are
793 pointer targets by taking their TYPE_MAIN_VARIANT. */
794 mvl
= TREE_TYPE (ttl
);
795 mvr
= TREE_TYPE (ttr
);
796 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
797 mvl
= TYPE_MAIN_VARIANT (mvl
);
798 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
799 mvr
= TYPE_MAIN_VARIANT (mvr
);
800 val
= comptypes (mvl
, mvr
);
802 if (val
== 2 && pedantic
)
803 pedwarn ("types are not quite compatible");
807 /* Subroutines of `comptypes'. */
809 /* Determine whether two trees derive from the same translation unit.
810 If the CONTEXT chain ends in a null, that tree's context is still
811 being parsed, so if two trees have context chains ending in null,
812 they're in the same translation unit. */
814 same_translation_unit_p (tree t1
, tree t2
)
816 while (t1
&& TREE_CODE (t1
) != TRANSLATION_UNIT_DECL
)
817 switch (TREE_CODE_CLASS (TREE_CODE (t1
)))
819 case tcc_declaration
:
820 t1
= DECL_CONTEXT (t1
); break;
822 t1
= TYPE_CONTEXT (t1
); break;
823 case tcc_exceptional
:
824 t1
= BLOCK_SUPERCONTEXT (t1
); break; /* assume block */
825 default: gcc_unreachable ();
828 while (t2
&& TREE_CODE (t2
) != TRANSLATION_UNIT_DECL
)
829 switch (TREE_CODE_CLASS (TREE_CODE (t2
)))
831 case tcc_declaration
:
832 t2
= DECL_CONTEXT (t2
); break;
834 t2
= TYPE_CONTEXT (t2
); break;
835 case tcc_exceptional
:
836 t2
= BLOCK_SUPERCONTEXT (t2
); break; /* assume block */
837 default: gcc_unreachable ();
843 /* The C standard says that two structures in different translation
844 units are compatible with each other only if the types of their
845 fields are compatible (among other things). So, consider two copies
846 of this structure: */
848 struct tagged_tu_seen
{
849 const struct tagged_tu_seen
* next
;
854 /* Can they be compatible with each other? We choose to break the
855 recursion by allowing those types to be compatible. */
857 static const struct tagged_tu_seen
* tagged_tu_seen_base
;
859 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
860 compatible. If the two types are not the same (which has been
861 checked earlier), this can only happen when multiple translation
862 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
866 tagged_types_tu_compatible_p (tree t1
, tree t2
)
869 bool needs_warning
= false;
871 /* We have to verify that the tags of the types are the same. This
872 is harder than it looks because this may be a typedef, so we have
873 to go look at the original type. It may even be a typedef of a
875 In the case of compiler-created builtin structs the TYPE_DECL
876 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
877 while (TYPE_NAME (t1
)
878 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
879 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1
)))
880 t1
= DECL_ORIGINAL_TYPE (TYPE_NAME (t1
));
882 while (TYPE_NAME (t2
)
883 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
884 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2
)))
885 t2
= DECL_ORIGINAL_TYPE (TYPE_NAME (t2
));
887 /* C90 didn't have the requirement that the two tags be the same. */
888 if (flag_isoc99
&& TYPE_NAME (t1
) != TYPE_NAME (t2
))
891 /* C90 didn't say what happened if one or both of the types were
892 incomplete; we choose to follow C99 rules here, which is that they
894 if (TYPE_SIZE (t1
) == NULL
895 || TYPE_SIZE (t2
) == NULL
)
899 const struct tagged_tu_seen
* tts_i
;
900 for (tts_i
= tagged_tu_seen_base
; tts_i
!= NULL
; tts_i
= tts_i
->next
)
901 if (tts_i
->t1
== t1
&& tts_i
->t2
== t2
)
905 switch (TREE_CODE (t1
))
910 /* Speed up the case where the type values are in the same order. */
911 tree tv1
= TYPE_VALUES (t1
);
912 tree tv2
= TYPE_VALUES (t2
);
917 for (;tv1
&& tv2
; tv1
= TREE_CHAIN (tv1
), tv2
= TREE_CHAIN (tv2
))
919 if (TREE_PURPOSE (tv1
) != TREE_PURPOSE (tv2
))
921 if (simple_cst_equal (TREE_VALUE (tv1
), TREE_VALUE (tv2
)) != 1)
925 if (tv1
== NULL_TREE
&& tv2
== NULL_TREE
)
927 if (tv1
== NULL_TREE
|| tv2
== NULL_TREE
)
930 if (list_length (TYPE_VALUES (t1
)) != list_length (TYPE_VALUES (t2
)))
933 for (s1
= TYPE_VALUES (t1
); s1
; s1
= TREE_CHAIN (s1
))
935 s2
= purpose_member (TREE_PURPOSE (s1
), TYPE_VALUES (t2
));
937 || simple_cst_equal (TREE_VALUE (s1
), TREE_VALUE (s2
)) != 1)
945 if (list_length (TYPE_FIELDS (t1
)) != list_length (TYPE_FIELDS (t2
)))
948 for (s1
= TYPE_FIELDS (t1
); s1
; s1
= TREE_CHAIN (s1
))
951 struct tagged_tu_seen tts
;
953 tts
.next
= tagged_tu_seen_base
;
956 tagged_tu_seen_base
= &tts
;
958 if (DECL_NAME (s1
) != NULL
)
959 for (s2
= TYPE_FIELDS (t2
); s2
; s2
= TREE_CHAIN (s2
))
960 if (DECL_NAME (s1
) == DECL_NAME (s2
))
963 result
= comptypes (TREE_TYPE (s1
), TREE_TYPE (s2
));
967 needs_warning
= true;
969 if (TREE_CODE (s1
) == FIELD_DECL
970 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
971 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
977 tagged_tu_seen_base
= tts
.next
;
981 return needs_warning
? 2 : 1;
986 struct tagged_tu_seen tts
;
988 tts
.next
= tagged_tu_seen_base
;
991 tagged_tu_seen_base
= &tts
;
993 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
);
995 s1
= TREE_CHAIN (s1
), s2
= TREE_CHAIN (s2
))
998 if (TREE_CODE (s1
) != TREE_CODE (s2
)
999 || DECL_NAME (s1
) != DECL_NAME (s2
))
1001 result
= comptypes (TREE_TYPE (s1
), TREE_TYPE (s2
));
1005 needs_warning
= true;
1007 if (TREE_CODE (s1
) == FIELD_DECL
1008 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1009 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1012 tagged_tu_seen_base
= tts
.next
;
1015 return needs_warning
? 2 : 1;
1023 /* Return 1 if two function types F1 and F2 are compatible.
1024 If either type specifies no argument types,
1025 the other must specify a fixed number of self-promoting arg types.
1026 Otherwise, if one type specifies only the number of arguments,
1027 the other must specify that number of self-promoting arg types.
1028 Otherwise, the argument types must match. */
1031 function_types_compatible_p (tree f1
, tree f2
)
1034 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1039 ret1
= TREE_TYPE (f1
);
1040 ret2
= TREE_TYPE (f2
);
1042 /* 'volatile' qualifiers on a function's return type used to mean
1043 the function is noreturn. */
1044 if (TYPE_VOLATILE (ret1
) != TYPE_VOLATILE (ret2
))
1045 pedwarn ("function return types not compatible due to %<volatile%>");
1046 if (TYPE_VOLATILE (ret1
))
1047 ret1
= build_qualified_type (TYPE_MAIN_VARIANT (ret1
),
1048 TYPE_QUALS (ret1
) & ~TYPE_QUAL_VOLATILE
);
1049 if (TYPE_VOLATILE (ret2
))
1050 ret2
= build_qualified_type (TYPE_MAIN_VARIANT (ret2
),
1051 TYPE_QUALS (ret2
) & ~TYPE_QUAL_VOLATILE
);
1052 val
= comptypes (ret1
, ret2
);
1056 args1
= TYPE_ARG_TYPES (f1
);
1057 args2
= TYPE_ARG_TYPES (f2
);
1059 /* An unspecified parmlist matches any specified parmlist
1060 whose argument types don't need default promotions. */
1064 if (!self_promoting_args_p (args2
))
1066 /* If one of these types comes from a non-prototype fn definition,
1067 compare that with the other type's arglist.
1068 If they don't match, ask for a warning (but no error). */
1069 if (TYPE_ACTUAL_ARG_TYPES (f1
)
1070 && 1 != type_lists_compatible_p (args2
, TYPE_ACTUAL_ARG_TYPES (f1
)))
1076 if (!self_promoting_args_p (args1
))
1078 if (TYPE_ACTUAL_ARG_TYPES (f2
)
1079 && 1 != type_lists_compatible_p (args1
, TYPE_ACTUAL_ARG_TYPES (f2
)))
1084 /* Both types have argument lists: compare them and propagate results. */
1085 val1
= type_lists_compatible_p (args1
, args2
);
1086 return val1
!= 1 ? val1
: val
;
1089 /* Check two lists of types for compatibility,
1090 returning 0 for incompatible, 1 for compatible,
1091 or 2 for compatible with warning. */
1094 type_lists_compatible_p (tree args1
, tree args2
)
1096 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1102 tree a1
, mv1
, a2
, mv2
;
1103 if (args1
== 0 && args2
== 0)
1105 /* If one list is shorter than the other,
1106 they fail to match. */
1107 if (args1
== 0 || args2
== 0)
1109 mv1
= a1
= TREE_VALUE (args1
);
1110 mv2
= a2
= TREE_VALUE (args2
);
1111 if (mv1
&& mv1
!= error_mark_node
&& TREE_CODE (mv1
) != ARRAY_TYPE
)
1112 mv1
= TYPE_MAIN_VARIANT (mv1
);
1113 if (mv2
&& mv2
!= error_mark_node
&& TREE_CODE (mv2
) != ARRAY_TYPE
)
1114 mv2
= TYPE_MAIN_VARIANT (mv2
);
1115 /* A null pointer instead of a type
1116 means there is supposed to be an argument
1117 but nothing is specified about what type it has.
1118 So match anything that self-promotes. */
1121 if (c_type_promotes_to (a2
) != a2
)
1126 if (c_type_promotes_to (a1
) != a1
)
1129 /* If one of the lists has an error marker, ignore this arg. */
1130 else if (TREE_CODE (a1
) == ERROR_MARK
1131 || TREE_CODE (a2
) == ERROR_MARK
)
1133 else if (!(newval
= comptypes (mv1
, mv2
)))
1135 /* Allow wait (union {union wait *u; int *i} *)
1136 and wait (union wait *) to be compatible. */
1137 if (TREE_CODE (a1
) == UNION_TYPE
1138 && (TYPE_NAME (a1
) == 0
1139 || TYPE_TRANSPARENT_UNION (a1
))
1140 && TREE_CODE (TYPE_SIZE (a1
)) == INTEGER_CST
1141 && tree_int_cst_equal (TYPE_SIZE (a1
),
1145 for (memb
= TYPE_FIELDS (a1
);
1146 memb
; memb
= TREE_CHAIN (memb
))
1148 tree mv3
= TREE_TYPE (memb
);
1149 if (mv3
&& mv3
!= error_mark_node
1150 && TREE_CODE (mv3
) != ARRAY_TYPE
)
1151 mv3
= TYPE_MAIN_VARIANT (mv3
);
1152 if (comptypes (mv3
, mv2
))
1158 else if (TREE_CODE (a2
) == UNION_TYPE
1159 && (TYPE_NAME (a2
) == 0
1160 || TYPE_TRANSPARENT_UNION (a2
))
1161 && TREE_CODE (TYPE_SIZE (a2
)) == INTEGER_CST
1162 && tree_int_cst_equal (TYPE_SIZE (a2
),
1166 for (memb
= TYPE_FIELDS (a2
);
1167 memb
; memb
= TREE_CHAIN (memb
))
1169 tree mv3
= TREE_TYPE (memb
);
1170 if (mv3
&& mv3
!= error_mark_node
1171 && TREE_CODE (mv3
) != ARRAY_TYPE
)
1172 mv3
= TYPE_MAIN_VARIANT (mv3
);
1173 if (comptypes (mv3
, mv1
))
1183 /* comptypes said ok, but record if it said to warn. */
1187 args1
= TREE_CHAIN (args1
);
1188 args2
= TREE_CHAIN (args2
);
1192 /* Compute the size to increment a pointer by. */
1195 c_size_in_bytes (tree type
)
1197 enum tree_code code
= TREE_CODE (type
);
1199 if (code
== FUNCTION_TYPE
|| code
== VOID_TYPE
|| code
== ERROR_MARK
)
1200 return size_one_node
;
1202 if (!COMPLETE_OR_VOID_TYPE_P (type
))
1204 error ("arithmetic on pointer to an incomplete type");
1205 return size_one_node
;
1208 /* Convert in case a char is more than one unit. */
1209 return size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
1210 size_int (TYPE_PRECISION (char_type_node
)
1214 /* Return either DECL or its known constant value (if it has one). */
1217 decl_constant_value (tree decl
)
1219 if (/* Don't change a variable array bound or initial value to a constant
1220 in a place where a variable is invalid. Note that DECL_INITIAL
1221 isn't valid for a PARM_DECL. */
1222 current_function_decl
!= 0
1223 && TREE_CODE (decl
) != PARM_DECL
1224 && !TREE_THIS_VOLATILE (decl
)
1225 && TREE_READONLY (decl
)
1226 && DECL_INITIAL (decl
) != 0
1227 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
1228 /* This is invalid if initial value is not constant.
1229 If it has either a function call, a memory reference,
1230 or a variable, then re-evaluating it could give different results. */
1231 && TREE_CONSTANT (DECL_INITIAL (decl
))
1232 /* Check for cases where this is sub-optimal, even though valid. */
1233 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1234 return DECL_INITIAL (decl
);
1238 /* Return either DECL or its known constant value (if it has one), but
1239 return DECL if pedantic or DECL has mode BLKmode. This is for
1240 bug-compatibility with the old behavior of decl_constant_value
1241 (before GCC 3.0); every use of this function is a bug and it should
1242 be removed before GCC 3.1. It is not appropriate to use pedantic
1243 in a way that affects optimization, and BLKmode is probably not the
1244 right test for avoiding misoptimizations either. */
1247 decl_constant_value_for_broken_optimization (tree decl
)
1249 if (pedantic
|| DECL_MODE (decl
) == BLKmode
)
1252 return decl_constant_value (decl
);
1256 /* Perform the default conversion of arrays and functions to pointers.
1257 Return the result of converting EXP. For any other expression, just
1261 default_function_array_conversion (tree exp
)
1264 tree type
= TREE_TYPE (exp
);
1265 enum tree_code code
= TREE_CODE (type
);
1268 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1271 Do not use STRIP_NOPS here! It will remove conversions from pointer
1272 to integer and cause infinite recursion. */
1274 while (TREE_CODE (exp
) == NON_LVALUE_EXPR
1275 || (TREE_CODE (exp
) == NOP_EXPR
1276 && TREE_TYPE (TREE_OPERAND (exp
, 0)) == TREE_TYPE (exp
)))
1278 if (TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1280 exp
= TREE_OPERAND (exp
, 0);
1283 if (TREE_NO_WARNING (orig_exp
))
1284 TREE_NO_WARNING (exp
) = 1;
1286 if (code
== FUNCTION_TYPE
)
1288 return build_unary_op (ADDR_EXPR
, exp
, 0);
1290 if (code
== ARRAY_TYPE
)
1293 tree restype
= TREE_TYPE (type
);
1299 if (REFERENCE_CLASS_P (exp
) || DECL_P (exp
))
1301 constp
= TREE_READONLY (exp
);
1302 volatilep
= TREE_THIS_VOLATILE (exp
);
1305 if (TYPE_QUALS (type
) || constp
|| volatilep
)
1307 = c_build_qualified_type (restype
,
1309 | (constp
* TYPE_QUAL_CONST
)
1310 | (volatilep
* TYPE_QUAL_VOLATILE
));
1312 if (TREE_CODE (exp
) == INDIRECT_REF
)
1313 return convert (build_pointer_type (restype
),
1314 TREE_OPERAND (exp
, 0));
1316 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
1318 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
1319 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
1320 TREE_OPERAND (exp
, 0), op1
);
1323 lvalue_array_p
= !not_lvalue
&& lvalue_p (exp
);
1324 if (!flag_isoc99
&& !lvalue_array_p
)
1326 /* Before C99, non-lvalue arrays do not decay to pointers.
1327 Normally, using such an array would be invalid; but it can
1328 be used correctly inside sizeof or as a statement expression.
1329 Thus, do not give an error here; an error will result later. */
1333 ptrtype
= build_pointer_type (restype
);
1335 if (TREE_CODE (exp
) == VAR_DECL
)
1337 /* We are making an ADDR_EXPR of ptrtype. This is a valid
1338 ADDR_EXPR because it's the best way of representing what
1339 happens in C when we take the address of an array and place
1340 it in a pointer to the element type. */
1341 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
1342 if (!c_mark_addressable (exp
))
1343 return error_mark_node
;
1344 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
1347 /* This way is better for a COMPONENT_REF since it can
1348 simplify the offset for a component. */
1349 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
1350 return convert (ptrtype
, adr
);
1355 /* Perform default promotions for C data used in expressions.
1356 Arrays and functions are converted to pointers;
1357 enumeral types or short or char, to int.
1358 In addition, manifest constants symbols are replaced by their values. */
1361 default_conversion (tree exp
)
1364 tree type
= TREE_TYPE (exp
);
1365 enum tree_code code
= TREE_CODE (type
);
1367 if (code
== FUNCTION_TYPE
|| code
== ARRAY_TYPE
)
1368 return default_function_array_conversion (exp
);
1370 /* Constants can be used directly unless they're not loadable. */
1371 if (TREE_CODE (exp
) == CONST_DECL
)
1372 exp
= DECL_INITIAL (exp
);
1374 /* Replace a nonvolatile const static variable with its value unless
1375 it is an array, in which case we must be sure that taking the
1376 address of the array produces consistent results. */
1377 else if (optimize
&& TREE_CODE (exp
) == VAR_DECL
&& code
!= ARRAY_TYPE
)
1379 exp
= decl_constant_value_for_broken_optimization (exp
);
1380 type
= TREE_TYPE (exp
);
1383 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1386 Do not use STRIP_NOPS here! It will remove conversions from pointer
1387 to integer and cause infinite recursion. */
1389 while (TREE_CODE (exp
) == NON_LVALUE_EXPR
1390 || (TREE_CODE (exp
) == NOP_EXPR
1391 && TREE_TYPE (TREE_OPERAND (exp
, 0)) == TREE_TYPE (exp
)))
1392 exp
= TREE_OPERAND (exp
, 0);
1394 if (TREE_NO_WARNING (orig_exp
))
1395 TREE_NO_WARNING (exp
) = 1;
1397 /* Normally convert enums to int,
1398 but convert wide enums to something wider. */
1399 if (code
== ENUMERAL_TYPE
)
1401 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
1402 TYPE_PRECISION (integer_type_node
)),
1403 ((TYPE_PRECISION (type
)
1404 >= TYPE_PRECISION (integer_type_node
))
1405 && TYPE_UNSIGNED (type
)));
1407 return convert (type
, exp
);
1410 if (TREE_CODE (exp
) == COMPONENT_REF
1411 && DECL_C_BIT_FIELD (TREE_OPERAND (exp
, 1))
1412 /* If it's thinner than an int, promote it like a
1413 c_promoting_integer_type_p, otherwise leave it alone. */
1414 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp
, 1)),
1415 TYPE_PRECISION (integer_type_node
)))
1416 return convert (integer_type_node
, exp
);
1418 if (c_promoting_integer_type_p (type
))
1420 /* Preserve unsignedness if not really getting any wider. */
1421 if (TYPE_UNSIGNED (type
)
1422 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1423 return convert (unsigned_type_node
, exp
);
1425 return convert (integer_type_node
, exp
);
1428 if (code
== VOID_TYPE
)
1430 error ("void value not ignored as it ought to be");
1431 return error_mark_node
;
1436 /* Look up COMPONENT in a structure or union DECL.
1438 If the component name is not found, returns NULL_TREE. Otherwise,
1439 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1440 stepping down the chain to the component, which is in the last
1441 TREE_VALUE of the list. Normally the list is of length one, but if
1442 the component is embedded within (nested) anonymous structures or
1443 unions, the list steps down the chain to the component. */
1446 lookup_field (tree decl
, tree component
)
1448 tree type
= TREE_TYPE (decl
);
1451 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1452 to the field elements. Use a binary search on this array to quickly
1453 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1454 will always be set for structures which have many elements. */
1456 if (TYPE_LANG_SPECIFIC (type
) && TYPE_LANG_SPECIFIC (type
)->s
)
1459 tree
*field_array
= &TYPE_LANG_SPECIFIC (type
)->s
->elts
[0];
1461 field
= TYPE_FIELDS (type
);
1463 top
= TYPE_LANG_SPECIFIC (type
)->s
->len
;
1464 while (top
- bot
> 1)
1466 half
= (top
- bot
+ 1) >> 1;
1467 field
= field_array
[bot
+half
];
1469 if (DECL_NAME (field
) == NULL_TREE
)
1471 /* Step through all anon unions in linear fashion. */
1472 while (DECL_NAME (field_array
[bot
]) == NULL_TREE
)
1474 field
= field_array
[bot
++];
1475 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
1476 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
1478 tree anon
= lookup_field (field
, component
);
1481 return tree_cons (NULL_TREE
, field
, anon
);
1485 /* Entire record is only anon unions. */
1489 /* Restart the binary search, with new lower bound. */
1493 if (DECL_NAME (field
) == component
)
1495 if (DECL_NAME (field
) < component
)
1501 if (DECL_NAME (field_array
[bot
]) == component
)
1502 field
= field_array
[bot
];
1503 else if (DECL_NAME (field
) != component
)
1508 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1510 if (DECL_NAME (field
) == NULL_TREE
1511 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
1512 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
))
1514 tree anon
= lookup_field (field
, component
);
1517 return tree_cons (NULL_TREE
, field
, anon
);
1520 if (DECL_NAME (field
) == component
)
1524 if (field
== NULL_TREE
)
1528 return tree_cons (NULL_TREE
, field
, NULL_TREE
);
1531 /* Make an expression to refer to the COMPONENT field of
1532 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1535 build_component_ref (tree datum
, tree component
)
1537 tree type
= TREE_TYPE (datum
);
1538 enum tree_code code
= TREE_CODE (type
);
1542 if (!objc_is_public (datum
, component
))
1543 return error_mark_node
;
1545 /* See if there is a field or component with name COMPONENT. */
1547 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
1549 if (!COMPLETE_TYPE_P (type
))
1551 c_incomplete_type_error (NULL_TREE
, type
);
1552 return error_mark_node
;
1555 field
= lookup_field (datum
, component
);
1559 error ("%qT has no member named %qs", type
,
1560 IDENTIFIER_POINTER (component
));
1561 return error_mark_node
;
1564 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1565 This might be better solved in future the way the C++ front
1566 end does it - by giving the anonymous entities each a
1567 separate name and type, and then have build_component_ref
1568 recursively call itself. We can't do that here. */
1571 tree subdatum
= TREE_VALUE (field
);
1573 if (TREE_TYPE (subdatum
) == error_mark_node
)
1574 return error_mark_node
;
1576 ref
= build3 (COMPONENT_REF
, TREE_TYPE (subdatum
), datum
, subdatum
,
1578 if (TREE_READONLY (datum
) || TREE_READONLY (subdatum
))
1579 TREE_READONLY (ref
) = 1;
1580 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (subdatum
))
1581 TREE_THIS_VOLATILE (ref
) = 1;
1583 if (TREE_DEPRECATED (subdatum
))
1584 warn_deprecated_use (subdatum
);
1588 field
= TREE_CHAIN (field
);
1594 else if (code
!= ERROR_MARK
)
1595 error ("request for member %qs in something not a structure or union",
1596 IDENTIFIER_POINTER (component
));
1598 return error_mark_node
;
1601 /* Given an expression PTR for a pointer, return an expression
1602 for the value pointed to.
1603 ERRORSTRING is the name of the operator to appear in error messages. */
1606 build_indirect_ref (tree ptr
, const char *errorstring
)
1608 tree pointer
= default_conversion (ptr
);
1609 tree type
= TREE_TYPE (pointer
);
1611 if (TREE_CODE (type
) == POINTER_TYPE
)
1613 if (TREE_CODE (pointer
) == ADDR_EXPR
1614 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1615 == TREE_TYPE (type
)))
1616 return TREE_OPERAND (pointer
, 0);
1619 tree t
= TREE_TYPE (type
);
1623 if (TREE_CODE (mvt
) != ARRAY_TYPE
)
1624 mvt
= TYPE_MAIN_VARIANT (mvt
);
1625 ref
= build1 (INDIRECT_REF
, mvt
, pointer
);
1627 if (!COMPLETE_OR_VOID_TYPE_P (t
) && TREE_CODE (t
) != ARRAY_TYPE
)
1629 error ("dereferencing pointer to incomplete type");
1630 return error_mark_node
;
1632 if (VOID_TYPE_P (t
) && skip_evaluation
== 0)
1633 warning ("dereferencing %<void *%> pointer");
1635 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1636 so that we get the proper error message if the result is used
1637 to assign to. Also, &* is supposed to be a no-op.
1638 And ANSI C seems to specify that the type of the result
1639 should be the const type. */
1640 /* A de-reference of a pointer to const is not a const. It is valid
1641 to change it via some other pointer. */
1642 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1643 TREE_SIDE_EFFECTS (ref
)
1644 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
1645 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1649 else if (TREE_CODE (pointer
) != ERROR_MARK
)
1650 error ("invalid type argument of %qs", errorstring
);
1651 return error_mark_node
;
1654 /* This handles expressions of the form "a[i]", which denotes
1657 This is logically equivalent in C to *(a+i), but we may do it differently.
1658 If A is a variable or a member, we generate a primitive ARRAY_REF.
1659 This avoids forcing the array out of registers, and can work on
1660 arrays that are not lvalues (for example, members of structures returned
1664 build_array_ref (tree array
, tree index
)
1666 bool swapped
= false;
1667 if (TREE_TYPE (array
) == error_mark_node
1668 || TREE_TYPE (index
) == error_mark_node
)
1669 return error_mark_node
;
1671 if (TREE_CODE (TREE_TYPE (array
)) != ARRAY_TYPE
1672 && TREE_CODE (TREE_TYPE (array
)) != POINTER_TYPE
)
1675 if (TREE_CODE (TREE_TYPE (index
)) != ARRAY_TYPE
1676 && TREE_CODE (TREE_TYPE (index
)) != POINTER_TYPE
)
1678 error ("subscripted value is neither array nor pointer");
1679 return error_mark_node
;
1687 if (!INTEGRAL_TYPE_P (TREE_TYPE (index
)))
1689 error ("array subscript is not an integer");
1690 return error_mark_node
;
1693 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array
))) == FUNCTION_TYPE
)
1695 error ("subscripted value is pointer to function");
1696 return error_mark_node
;
1699 /* Subscripting with type char is likely to lose on a machine where
1700 chars are signed. So warn on any machine, but optionally. Don't
1701 warn for unsigned char since that type is safe. Don't warn for
1702 signed char because anyone who uses that must have done so
1703 deliberately. ??? Existing practice has also been to warn only
1704 when the char index is syntactically the index, not for
1706 if (warn_char_subscripts
&& !swapped
1707 && TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
)
1708 warning ("array subscript has type %<char%>");
1710 /* Apply default promotions *after* noticing character types. */
1711 index
= default_conversion (index
);
1713 gcc_assert (TREE_CODE (TREE_TYPE (index
)) == INTEGER_TYPE
);
1715 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
1719 /* An array that is indexed by a non-constant
1720 cannot be stored in a register; we must be able to do
1721 address arithmetic on its address.
1722 Likewise an array of elements of variable size. */
1723 if (TREE_CODE (index
) != INTEGER_CST
1724 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
1725 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1727 if (!c_mark_addressable (array
))
1728 return error_mark_node
;
1730 /* An array that is indexed by a constant value which is not within
1731 the array bounds cannot be stored in a register either; because we
1732 would get a crash in store_bit_field/extract_bit_field when trying
1733 to access a non-existent part of the register. */
1734 if (TREE_CODE (index
) == INTEGER_CST
1735 && TYPE_DOMAIN (TREE_TYPE (array
))
1736 && !int_fits_type_p (index
, TYPE_DOMAIN (TREE_TYPE (array
))))
1738 if (!c_mark_addressable (array
))
1739 return error_mark_node
;
1745 while (TREE_CODE (foo
) == COMPONENT_REF
)
1746 foo
= TREE_OPERAND (foo
, 0);
1747 if (TREE_CODE (foo
) == VAR_DECL
&& C_DECL_REGISTER (foo
))
1748 pedwarn ("ISO C forbids subscripting %<register%> array");
1749 else if (!flag_isoc99
&& !lvalue_p (foo
))
1750 pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1753 type
= TREE_TYPE (TREE_TYPE (array
));
1754 if (TREE_CODE (type
) != ARRAY_TYPE
)
1755 type
= TYPE_MAIN_VARIANT (type
);
1756 rval
= build4 (ARRAY_REF
, type
, array
, index
, NULL_TREE
, NULL_TREE
);
1757 /* Array ref is const/volatile if the array elements are
1758 or if the array is. */
1759 TREE_READONLY (rval
)
1760 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1761 | TREE_READONLY (array
));
1762 TREE_SIDE_EFFECTS (rval
)
1763 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1764 | TREE_SIDE_EFFECTS (array
));
1765 TREE_THIS_VOLATILE (rval
)
1766 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1767 /* This was added by rms on 16 Nov 91.
1768 It fixes vol struct foo *a; a->elts[1]
1769 in an inline function.
1770 Hope it doesn't break something else. */
1771 | TREE_THIS_VOLATILE (array
));
1772 return require_complete_type (fold (rval
));
1776 tree ar
= default_conversion (array
);
1778 if (ar
== error_mark_node
)
1781 gcc_assert (TREE_CODE (TREE_TYPE (ar
)) == POINTER_TYPE
);
1782 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar
))) != FUNCTION_TYPE
);
1784 return build_indirect_ref (build_binary_op (PLUS_EXPR
, ar
, index
, 0),
1789 /* Build an external reference to identifier ID. FUN indicates
1790 whether this will be used for a function call. */
1792 build_external_ref (tree id
, int fun
)
1795 tree decl
= lookup_name (id
);
1797 /* In Objective-C, an instance variable (ivar) may be preferred to
1798 whatever lookup_name() found. */
1799 decl
= objc_lookup_ivar (decl
, id
);
1801 if (decl
&& decl
!= error_mark_node
)
1804 /* Implicit function declaration. */
1805 ref
= implicitly_declare (id
);
1806 else if (decl
== error_mark_node
)
1807 /* Don't complain about something that's already been
1808 complained about. */
1809 return error_mark_node
;
1812 undeclared_variable (id
);
1813 return error_mark_node
;
1816 if (TREE_TYPE (ref
) == error_mark_node
)
1817 return error_mark_node
;
1819 if (TREE_DEPRECATED (ref
))
1820 warn_deprecated_use (ref
);
1822 if (!skip_evaluation
)
1823 assemble_external (ref
);
1824 TREE_USED (ref
) = 1;
1826 if (TREE_CODE (ref
) == FUNCTION_DECL
&& !in_alignof
)
1828 if (!in_sizeof
&& !in_typeof
)
1829 C_DECL_USED (ref
) = 1;
1830 else if (DECL_INITIAL (ref
) == 0
1831 && DECL_EXTERNAL (ref
)
1832 && !TREE_PUBLIC (ref
))
1833 record_maybe_used_decl (ref
);
1836 if (TREE_CODE (ref
) == CONST_DECL
)
1838 ref
= DECL_INITIAL (ref
);
1839 TREE_CONSTANT (ref
) = 1;
1840 TREE_INVARIANT (ref
) = 1;
1842 else if (current_function_decl
!= 0
1843 && !DECL_FILE_SCOPE_P (current_function_decl
)
1844 && (TREE_CODE (ref
) == VAR_DECL
1845 || TREE_CODE (ref
) == PARM_DECL
1846 || TREE_CODE (ref
) == FUNCTION_DECL
))
1848 tree context
= decl_function_context (ref
);
1850 if (context
!= 0 && context
!= current_function_decl
)
1851 DECL_NONLOCAL (ref
) = 1;
1857 /* Record details of decls possibly used inside sizeof or typeof. */
1858 struct maybe_used_decl
1862 /* The level seen at (in_sizeof + in_typeof). */
1864 /* The next one at this level or above, or NULL. */
1865 struct maybe_used_decl
*next
;
1868 static struct maybe_used_decl
*maybe_used_decls
;
1870 /* Record that DECL, an undefined static function reference seen
1871 inside sizeof or typeof, might be used if the operand of sizeof is
1872 a VLA type or the operand of typeof is a variably modified
1876 record_maybe_used_decl (tree decl
)
1878 struct maybe_used_decl
*t
= XOBNEW (&parser_obstack
, struct maybe_used_decl
);
1880 t
->level
= in_sizeof
+ in_typeof
;
1881 t
->next
= maybe_used_decls
;
1882 maybe_used_decls
= t
;
1885 /* Pop the stack of decls possibly used inside sizeof or typeof. If
1886 USED is false, just discard them. If it is true, mark them used
1887 (if no longer inside sizeof or typeof) or move them to the next
1888 level up (if still inside sizeof or typeof). */
1891 pop_maybe_used (bool used
)
1893 struct maybe_used_decl
*p
= maybe_used_decls
;
1894 int cur_level
= in_sizeof
+ in_typeof
;
1895 while (p
&& p
->level
> cur_level
)
1900 C_DECL_USED (p
->decl
) = 1;
1902 p
->level
= cur_level
;
1906 if (!used
|| cur_level
== 0)
1907 maybe_used_decls
= p
;
1910 /* Return the result of sizeof applied to EXPR. */
1913 c_expr_sizeof_expr (struct c_expr expr
)
1916 if (expr
.value
== error_mark_node
)
1918 ret
.value
= error_mark_node
;
1919 ret
.original_code
= ERROR_MARK
;
1920 pop_maybe_used (false);
1924 ret
.value
= c_sizeof (TREE_TYPE (expr
.value
));
1925 ret
.original_code
= ERROR_MARK
;
1926 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr
.value
)));
1931 /* Return the result of sizeof applied to T, a structure for the type
1932 name passed to sizeof (rather than the type itself). */
1935 c_expr_sizeof_type (struct c_type_name
*t
)
1939 type
= groktypename (t
);
1940 ret
.value
= c_sizeof (type
);
1941 ret
.original_code
= ERROR_MARK
;
1942 pop_maybe_used (C_TYPE_VARIABLE_SIZE (type
));
1946 /* Build a function call to function FUNCTION with parameters PARAMS.
1947 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1948 TREE_VALUE of each node is a parameter-expression.
1949 FUNCTION's data type may be a function type or a pointer-to-function. */
1952 build_function_call (tree function
, tree params
)
1954 tree fntype
, fundecl
= 0;
1955 tree coerced_params
;
1956 tree name
= NULL_TREE
, result
;
1959 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1960 STRIP_TYPE_NOPS (function
);
1962 /* Convert anything with function type to a pointer-to-function. */
1963 if (TREE_CODE (function
) == FUNCTION_DECL
)
1965 name
= DECL_NAME (function
);
1967 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1968 (because calling an inline function does not mean the function
1969 needs to be separately compiled). */
1970 fntype
= build_type_variant (TREE_TYPE (function
),
1971 TREE_READONLY (function
),
1972 TREE_THIS_VOLATILE (function
));
1974 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
1977 function
= default_conversion (function
);
1979 fntype
= TREE_TYPE (function
);
1981 if (TREE_CODE (fntype
) == ERROR_MARK
)
1982 return error_mark_node
;
1984 if (!(TREE_CODE (fntype
) == POINTER_TYPE
1985 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
1987 error ("called object %qE is not a function", function
);
1988 return error_mark_node
;
1991 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
1992 current_function_returns_abnormally
= 1;
1994 /* fntype now gets the type of function pointed to. */
1995 fntype
= TREE_TYPE (fntype
);
1997 /* Check that the function is called through a compatible prototype.
1998 If it is not, replace the call by a trap, wrapped up in a compound
1999 expression if necessary. This has the nice side-effect to prevent
2000 the tree-inliner from generating invalid assignment trees which may
2001 blow up in the RTL expander later.
2003 ??? This doesn't work for Objective-C because objc_comptypes
2004 refuses to compare function prototypes, yet the compiler appears
2005 to build calls that are flagged as invalid by C's comptypes. */
2006 if (!c_dialect_objc ()
2007 && TREE_CODE (function
) == NOP_EXPR
2008 && TREE_CODE (tem
= TREE_OPERAND (function
, 0)) == ADDR_EXPR
2009 && TREE_CODE (tem
= TREE_OPERAND (tem
, 0)) == FUNCTION_DECL
2010 && !comptypes (fntype
, TREE_TYPE (tem
)))
2012 tree return_type
= TREE_TYPE (fntype
);
2013 tree trap
= build_function_call (built_in_decls
[BUILT_IN_TRAP
],
2016 /* This situation leads to run-time undefined behavior. We can't,
2017 therefore, simply error unless we can prove that all possible
2018 executions of the program must execute the code. */
2019 warning ("function called through a non-compatible type");
2021 /* We can, however, treat "undefined" any way we please.
2022 Call abort to encourage the user to fix the program. */
2023 inform ("if this code is reached, the program will abort");
2025 if (VOID_TYPE_P (return_type
))
2031 if (AGGREGATE_TYPE_P (return_type
))
2032 rhs
= build_compound_literal (return_type
,
2033 build_constructor (return_type
,
2036 rhs
= fold (build1 (NOP_EXPR
, return_type
, integer_zero_node
));
2038 return build2 (COMPOUND_EXPR
, return_type
, trap
, rhs
);
2042 /* Convert the parameters to the types declared in the
2043 function prototype, or apply default promotions. */
2046 = convert_arguments (TYPE_ARG_TYPES (fntype
), params
, function
, fundecl
);
2048 if (coerced_params
== error_mark_node
)
2049 return error_mark_node
;
2051 /* Check that the arguments to the function are valid. */
2053 check_function_arguments (TYPE_ATTRIBUTES (fntype
), coerced_params
);
2055 result
= build3 (CALL_EXPR
, TREE_TYPE (fntype
),
2056 function
, coerced_params
, NULL_TREE
);
2057 TREE_SIDE_EFFECTS (result
) = 1;
2059 if (require_constant_value
)
2061 result
= fold_initializer (result
);
2063 if (TREE_CONSTANT (result
)
2064 && (name
== NULL_TREE
2065 || strncmp (IDENTIFIER_POINTER (name
), "__builtin_", 10) != 0))
2066 pedwarn_init ("initializer element is not constant");
2069 result
= fold (result
);
2071 if (VOID_TYPE_P (TREE_TYPE (result
)))
2073 return require_complete_type (result
);
2076 /* Convert the argument expressions in the list VALUES
2077 to the types in the list TYPELIST. The result is a list of converted
2078 argument expressions, unless there are too few arguments in which
2079 case it is error_mark_node.
2081 If TYPELIST is exhausted, or when an element has NULL as its type,
2082 perform the default conversions.
2084 PARMLIST is the chain of parm decls for the function being called.
2085 It may be 0, if that info is not available.
2086 It is used only for generating error messages.
2088 FUNCTION is a tree for the called function. It is used only for
2089 error messages, where it is formatted with %qE.
2091 This is also where warnings about wrong number of args are generated.
2093 Both VALUES and the returned value are chains of TREE_LIST nodes
2094 with the elements of the list in the TREE_VALUE slots of those nodes. */
2097 convert_arguments (tree typelist
, tree values
, tree function
, tree fundecl
)
2099 tree typetail
, valtail
;
2104 /* Change pointer to function to the function itself for
2106 if (TREE_CODE (function
) == ADDR_EXPR
2107 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
2108 function
= TREE_OPERAND (function
, 0);
2110 /* Handle an ObjC selector specially for diagnostics. */
2111 selector
= objc_message_selector ();
2113 /* Scan the given expressions and types, producing individual
2114 converted arguments and pushing them on RESULT in reverse order. */
2116 for (valtail
= values
, typetail
= typelist
, parmnum
= 0;
2118 valtail
= TREE_CHAIN (valtail
), parmnum
++)
2120 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2121 tree val
= TREE_VALUE (valtail
);
2122 tree rname
= function
;
2123 int argnum
= parmnum
+ 1;
2125 if (type
== void_type_node
)
2127 error ("too many arguments to function %qE", function
);
2131 if (selector
&& argnum
> 2)
2137 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
2138 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
2139 to convert automatically to a pointer. */
2140 if (TREE_CODE (val
) == NON_LVALUE_EXPR
)
2141 val
= TREE_OPERAND (val
, 0);
2143 val
= default_function_array_conversion (val
);
2145 val
= require_complete_type (val
);
2149 /* Formal parm type is specified by a function prototype. */
2152 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
2154 error ("type of formal parameter %d is incomplete", parmnum
+ 1);
2159 /* Optionally warn about conversions that
2160 differ from the default conversions. */
2161 if (warn_conversion
|| warn_traditional
)
2163 unsigned int formal_prec
= TYPE_PRECISION (type
);
2165 if (INTEGRAL_TYPE_P (type
)
2166 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2167 warning ("passing argument %d of %qE as integer "
2168 "rather than floating due to prototype",
2170 if (INTEGRAL_TYPE_P (type
)
2171 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
2172 warning ("passing argument %d of %qE as integer "
2173 "rather than complex due to prototype",
2175 else if (TREE_CODE (type
) == COMPLEX_TYPE
2176 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2177 warning ("passing argument %d of %qE as complex "
2178 "rather than floating due to prototype",
2180 else if (TREE_CODE (type
) == REAL_TYPE
2181 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2182 warning ("passing argument %d of %qE as floating "
2183 "rather than integer due to prototype",
2185 else if (TREE_CODE (type
) == COMPLEX_TYPE
2186 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2187 warning ("passing argument %d of %qE as complex "
2188 "rather than integer due to prototype",
2190 else if (TREE_CODE (type
) == REAL_TYPE
2191 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
2192 warning ("passing argument %d of %qE as floating "
2193 "rather than complex due to prototype",
2195 /* ??? At some point, messages should be written about
2196 conversions between complex types, but that's too messy
2198 else if (TREE_CODE (type
) == REAL_TYPE
2199 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2201 /* Warn if any argument is passed as `float',
2202 since without a prototype it would be `double'. */
2203 if (formal_prec
== TYPE_PRECISION (float_type_node
))
2204 warning ("passing argument %d of %qE as %<float%> "
2205 "rather than %<double%> due to prototype",
2208 /* Detect integer changing in width or signedness.
2209 These warnings are only activated with
2210 -Wconversion, not with -Wtraditional. */
2211 else if (warn_conversion
&& INTEGRAL_TYPE_P (type
)
2212 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2214 tree would_have_been
= default_conversion (val
);
2215 tree type1
= TREE_TYPE (would_have_been
);
2217 if (TREE_CODE (type
) == ENUMERAL_TYPE
2218 && (TYPE_MAIN_VARIANT (type
)
2219 == TYPE_MAIN_VARIANT (TREE_TYPE (val
))))
2220 /* No warning if function asks for enum
2221 and the actual arg is that enum type. */
2223 else if (formal_prec
!= TYPE_PRECISION (type1
))
2224 warning ("passing argument %d of %qE with different "
2225 "width due to prototype", argnum
, rname
);
2226 else if (TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (type1
))
2228 /* Don't complain if the formal parameter type
2229 is an enum, because we can't tell now whether
2230 the value was an enum--even the same enum. */
2231 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2233 else if (TREE_CODE (val
) == INTEGER_CST
2234 && int_fits_type_p (val
, type
))
2235 /* Change in signedness doesn't matter
2236 if a constant value is unaffected. */
2238 /* Likewise for a constant in a NOP_EXPR. */
2239 else if (TREE_CODE (val
) == NOP_EXPR
2240 && TREE_CODE (TREE_OPERAND (val
, 0)) == INTEGER_CST
2241 && int_fits_type_p (TREE_OPERAND (val
, 0), type
))
2243 /* If the value is extended from a narrower
2244 unsigned type, it doesn't matter whether we
2245 pass it as signed or unsigned; the value
2246 certainly is the same either way. */
2247 else if (TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
)
2248 && TYPE_UNSIGNED (TREE_TYPE (val
)))
2250 else if (TYPE_UNSIGNED (type
))
2251 warning ("passing argument %d of %qE as unsigned "
2252 "due to prototype", argnum
, rname
);
2254 warning ("passing argument %d of %qE as signed "
2255 "due to prototype", argnum
, rname
);
2259 parmval
= convert_for_assignment (type
, val
, ic_argpass
,
2263 if (targetm
.calls
.promote_prototypes (fundecl
? TREE_TYPE (fundecl
) : 0)
2264 && INTEGRAL_TYPE_P (type
)
2265 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2266 parmval
= default_conversion (parmval
);
2268 result
= tree_cons (NULL_TREE
, parmval
, result
);
2270 else if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2271 && (TYPE_PRECISION (TREE_TYPE (val
))
2272 < TYPE_PRECISION (double_type_node
)))
2273 /* Convert `float' to `double'. */
2274 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2276 /* Convert `short' and `char' to full-size `int'. */
2277 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2280 typetail
= TREE_CHAIN (typetail
);
2283 if (typetail
!= 0 && TREE_VALUE (typetail
) != void_type_node
)
2285 error ("too few arguments to function %qE", function
);
2286 return error_mark_node
;
2289 return nreverse (result
);
2292 /* This is the entry point used by the parser
2293 for binary operators in the input.
2294 In addition to constructing the expression,
2295 we check for operands that were written with other binary operators
2296 in a way that is likely to confuse the user. */
2299 parser_build_binary_op (enum tree_code code
, struct c_expr arg1
,
2302 struct c_expr result
;
2304 enum tree_code code1
= arg1
.original_code
;
2305 enum tree_code code2
= arg2
.original_code
;
2307 result
.value
= build_binary_op (code
, arg1
.value
, arg2
.value
, 1);
2308 result
.original_code
= code
;
2310 if (TREE_CODE (result
.value
) == ERROR_MARK
)
2313 /* Check for cases such as x+y<<z which users are likely
2315 if (warn_parentheses
)
2317 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
2319 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2320 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2321 warning ("suggest parentheses around + or - inside shift");
2324 if (code
== TRUTH_ORIF_EXPR
)
2326 if (code1
== TRUTH_ANDIF_EXPR
2327 || code2
== TRUTH_ANDIF_EXPR
)
2328 warning ("suggest parentheses around && within ||");
2331 if (code
== BIT_IOR_EXPR
)
2333 if (code1
== BIT_AND_EXPR
|| code1
== BIT_XOR_EXPR
2334 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2335 || code2
== BIT_AND_EXPR
|| code2
== BIT_XOR_EXPR
2336 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2337 warning ("suggest parentheses around arithmetic in operand of |");
2338 /* Check cases like x|y==z */
2339 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2340 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2341 warning ("suggest parentheses around comparison in operand of |");
2344 if (code
== BIT_XOR_EXPR
)
2346 if (code1
== BIT_AND_EXPR
2347 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2348 || code2
== BIT_AND_EXPR
2349 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2350 warning ("suggest parentheses around arithmetic in operand of ^");
2351 /* Check cases like x^y==z */
2352 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2353 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2354 warning ("suggest parentheses around comparison in operand of ^");
2357 if (code
== BIT_AND_EXPR
)
2359 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2360 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2361 warning ("suggest parentheses around + or - in operand of &");
2362 /* Check cases like x&y==z */
2363 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2364 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2365 warning ("suggest parentheses around comparison in operand of &");
2367 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
2368 if (TREE_CODE_CLASS (code
) == tcc_comparison
2369 && (TREE_CODE_CLASS (code1
) == tcc_comparison
2370 || TREE_CODE_CLASS (code2
) == tcc_comparison
))
2371 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2375 unsigned_conversion_warning (result
.value
, arg1
.value
);
2376 unsigned_conversion_warning (result
.value
, arg2
.value
);
2377 overflow_warning (result
.value
);
2382 /* Return a tree for the difference of pointers OP0 and OP1.
2383 The resulting tree has type int. */
2386 pointer_diff (tree op0
, tree op1
)
2388 tree restype
= ptrdiff_type_node
;
2390 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
2391 tree con0
, con1
, lit0
, lit1
;
2392 tree orig_op1
= op1
;
2394 if (pedantic
|| warn_pointer_arith
)
2396 if (TREE_CODE (target_type
) == VOID_TYPE
)
2397 pedwarn ("pointer of type %<void *%> used in subtraction");
2398 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
2399 pedwarn ("pointer to a function used in subtraction");
2402 /* If the conversion to ptrdiff_type does anything like widening or
2403 converting a partial to an integral mode, we get a convert_expression
2404 that is in the way to do any simplifications.
2405 (fold-const.c doesn't know that the extra bits won't be needed.
2406 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2407 different mode in place.)
2408 So first try to find a common term here 'by hand'; we want to cover
2409 at least the cases that occur in legal static initializers. */
2410 con0
= TREE_CODE (op0
) == NOP_EXPR
? TREE_OPERAND (op0
, 0) : op0
;
2411 con1
= TREE_CODE (op1
) == NOP_EXPR
? TREE_OPERAND (op1
, 0) : op1
;
2413 if (TREE_CODE (con0
) == PLUS_EXPR
)
2415 lit0
= TREE_OPERAND (con0
, 1);
2416 con0
= TREE_OPERAND (con0
, 0);
2419 lit0
= integer_zero_node
;
2421 if (TREE_CODE (con1
) == PLUS_EXPR
)
2423 lit1
= TREE_OPERAND (con1
, 1);
2424 con1
= TREE_OPERAND (con1
, 0);
2427 lit1
= integer_zero_node
;
2429 if (operand_equal_p (con0
, con1
, 0))
2436 /* First do the subtraction as integers;
2437 then drop through to build the divide operator.
2438 Do not do default conversions on the minus operator
2439 in case restype is a short type. */
2441 op0
= build_binary_op (MINUS_EXPR
, convert (restype
, op0
),
2442 convert (restype
, op1
), 0);
2443 /* This generates an error if op1 is pointer to incomplete type. */
2444 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1
))))
2445 error ("arithmetic on pointer to an incomplete type");
2447 /* This generates an error if op0 is pointer to incomplete type. */
2448 op1
= c_size_in_bytes (target_type
);
2450 /* Divide by the size, in easiest possible way. */
2451 return fold (build2 (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
)));
2454 /* Construct and perhaps optimize a tree representation
2455 for a unary operation. CODE, a tree_code, specifies the operation
2456 and XARG is the operand.
2457 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2458 the default promotions (such as from short to int).
2459 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2460 allows non-lvalues; this is only used to handle conversion of non-lvalue
2461 arrays to pointers in C99. */
2464 build_unary_op (enum tree_code code
, tree xarg
, int flag
)
2466 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2469 enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
2471 int noconvert
= flag
;
2473 if (typecode
== ERROR_MARK
)
2474 return error_mark_node
;
2475 if (typecode
== ENUMERAL_TYPE
|| typecode
== BOOLEAN_TYPE
)
2476 typecode
= INTEGER_TYPE
;
2481 /* This is used for unary plus, because a CONVERT_EXPR
2482 is enough to prevent anybody from looking inside for
2483 associativity, but won't generate any code. */
2484 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2485 || typecode
== COMPLEX_TYPE
2486 || typecode
== VECTOR_TYPE
))
2488 error ("wrong type argument to unary plus");
2489 return error_mark_node
;
2491 else if (!noconvert
)
2492 arg
= default_conversion (arg
);
2493 arg
= non_lvalue (arg
);
2497 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2498 || typecode
== COMPLEX_TYPE
2499 || typecode
== VECTOR_TYPE
))
2501 error ("wrong type argument to unary minus");
2502 return error_mark_node
;
2504 else if (!noconvert
)
2505 arg
= default_conversion (arg
);
2509 if (typecode
== INTEGER_TYPE
|| typecode
== VECTOR_TYPE
)
2512 arg
= default_conversion (arg
);
2514 else if (typecode
== COMPLEX_TYPE
)
2518 pedwarn ("ISO C does not support %<~%> for complex conjugation");
2520 arg
= default_conversion (arg
);
2524 error ("wrong type argument to bit-complement");
2525 return error_mark_node
;
2530 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
2532 error ("wrong type argument to abs");
2533 return error_mark_node
;
2535 else if (!noconvert
)
2536 arg
= default_conversion (arg
);
2540 /* Conjugating a real value is a no-op, but allow it anyway. */
2541 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2542 || typecode
== COMPLEX_TYPE
))
2544 error ("wrong type argument to conjugation");
2545 return error_mark_node
;
2547 else if (!noconvert
)
2548 arg
= default_conversion (arg
);
2551 case TRUTH_NOT_EXPR
:
2552 if (typecode
!= INTEGER_TYPE
2553 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
2554 && typecode
!= COMPLEX_TYPE
2555 /* These will convert to a pointer. */
2556 && typecode
!= ARRAY_TYPE
&& typecode
!= FUNCTION_TYPE
)
2558 error ("wrong type argument to unary exclamation mark");
2559 return error_mark_node
;
2561 arg
= lang_hooks
.truthvalue_conversion (arg
);
2562 return invert_truthvalue (arg
);
2568 if (TREE_CODE (arg
) == COMPLEX_CST
)
2569 return TREE_REALPART (arg
);
2570 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2571 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2576 if (TREE_CODE (arg
) == COMPLEX_CST
)
2577 return TREE_IMAGPART (arg
);
2578 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2579 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2581 return convert (TREE_TYPE (arg
), integer_zero_node
);
2583 case PREINCREMENT_EXPR
:
2584 case POSTINCREMENT_EXPR
:
2585 case PREDECREMENT_EXPR
:
2586 case POSTDECREMENT_EXPR
:
2588 /* Increment or decrement the real part of the value,
2589 and don't change the imaginary part. */
2590 if (typecode
== COMPLEX_TYPE
)
2595 pedwarn ("ISO C does not support %<++%> and %<--%>"
2596 " on complex types");
2598 arg
= stabilize_reference (arg
);
2599 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
2600 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
2601 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
2602 build_unary_op (code
, real
, 1), imag
);
2605 /* Report invalid types. */
2607 if (typecode
!= POINTER_TYPE
2608 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
2610 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2611 error ("wrong type argument to increment");
2613 error ("wrong type argument to decrement");
2615 return error_mark_node
;
2620 tree result_type
= TREE_TYPE (arg
);
2622 arg
= get_unwidened (arg
, 0);
2623 argtype
= TREE_TYPE (arg
);
2625 /* Compute the increment. */
2627 if (typecode
== POINTER_TYPE
)
2629 /* If pointer target is an undefined struct,
2630 we just cannot know how to do the arithmetic. */
2631 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type
)))
2633 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2634 error ("increment of pointer to unknown structure");
2636 error ("decrement of pointer to unknown structure");
2638 else if ((pedantic
|| warn_pointer_arith
)
2639 && (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
2640 || TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
))
2642 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2643 pedwarn ("wrong type argument to increment");
2645 pedwarn ("wrong type argument to decrement");
2648 inc
= c_size_in_bytes (TREE_TYPE (result_type
));
2651 inc
= integer_one_node
;
2653 inc
= convert (argtype
, inc
);
2655 /* Complain about anything else that is not a true lvalue. */
2656 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
2657 || code
== POSTINCREMENT_EXPR
)
2660 return error_mark_node
;
2662 /* Report a read-only lvalue. */
2663 if (TREE_READONLY (arg
))
2664 readonly_error (arg
,
2665 ((code
== PREINCREMENT_EXPR
2666 || code
== POSTINCREMENT_EXPR
)
2667 ? lv_increment
: lv_decrement
));
2669 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
2670 val
= boolean_increment (code
, arg
);
2672 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
2673 TREE_SIDE_EFFECTS (val
) = 1;
2674 val
= convert (result_type
, val
);
2675 if (TREE_CODE (val
) != code
)
2676 TREE_NO_WARNING (val
) = 1;
2681 /* Note that this operation never does default_conversion. */
2683 /* Let &* cancel out to simplify resulting code. */
2684 if (TREE_CODE (arg
) == INDIRECT_REF
)
2686 /* Don't let this be an lvalue. */
2687 if (lvalue_p (TREE_OPERAND (arg
, 0)))
2688 return non_lvalue (TREE_OPERAND (arg
, 0));
2689 return TREE_OPERAND (arg
, 0);
2692 /* For &x[y], return x+y */
2693 if (TREE_CODE (arg
) == ARRAY_REF
)
2695 if (!c_mark_addressable (TREE_OPERAND (arg
, 0)))
2696 return error_mark_node
;
2697 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
2698 TREE_OPERAND (arg
, 1), 1);
2701 /* Anything not already handled and not a true memory reference
2702 or a non-lvalue array is an error. */
2703 else if (typecode
!= FUNCTION_TYPE
&& !flag
2704 && !lvalue_or_else (arg
, lv_addressof
))
2705 return error_mark_node
;
2707 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
2708 argtype
= TREE_TYPE (arg
);
2710 /* If the lvalue is const or volatile, merge that into the type
2711 to which the address will point. Note that you can't get a
2712 restricted pointer by taking the address of something, so we
2713 only have to deal with `const' and `volatile' here. */
2714 if ((DECL_P (arg
) || REFERENCE_CLASS_P (arg
))
2715 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
)))
2716 argtype
= c_build_type_variant (argtype
,
2717 TREE_READONLY (arg
),
2718 TREE_THIS_VOLATILE (arg
));
2720 if (!c_mark_addressable (arg
))
2721 return error_mark_node
;
2723 gcc_assert (TREE_CODE (arg
) != COMPONENT_REF
2724 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)));
2726 argtype
= build_pointer_type (argtype
);
2728 /* ??? Cope with user tricks that amount to offsetof. Delete this
2729 when we have proper support for integer constant expressions. */
2730 val
= get_base_address (arg
);
2731 if (val
&& TREE_CODE (val
) == INDIRECT_REF
2732 && integer_zerop (TREE_OPERAND (val
, 0)))
2733 return fold_convert (argtype
, fold_offsetof (arg
));
2735 val
= build1 (ADDR_EXPR
, argtype
, arg
);
2737 if (TREE_CODE (arg
) == COMPOUND_LITERAL_EXPR
)
2738 TREE_INVARIANT (val
) = TREE_CONSTANT (val
) = 1;
2747 argtype
= TREE_TYPE (arg
);
2748 val
= build1 (code
, argtype
, arg
);
2749 return require_constant_value
? fold_initializer (val
) : fold (val
);
2752 /* Return nonzero if REF is an lvalue valid for this language.
2753 Lvalues can be assigned, unless their type has TYPE_READONLY.
2754 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
2759 enum tree_code code
= TREE_CODE (ref
);
2766 return lvalue_p (TREE_OPERAND (ref
, 0));
2768 case COMPOUND_LITERAL_EXPR
:
2778 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
2779 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
2782 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
2789 /* Give an error for storing in something that is 'const'. */
2792 readonly_error (tree arg
, enum lvalue_use use
)
2794 gcc_assert (use
== lv_assign
|| use
== lv_increment
|| use
== lv_decrement
);
2795 /* Using this macro rather than (for example) arrays of messages
2796 ensures that all the format strings are checked at compile
2798 #define READONLY_MSG(A, I, D) (use == lv_assign \
2800 : (use == lv_increment ? (I) : (D)))
2801 if (TREE_CODE (arg
) == COMPONENT_REF
)
2803 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
2804 readonly_error (TREE_OPERAND (arg
, 0), use
);
2806 error (READONLY_MSG (N_("assignment of read-only member %qs"),
2807 N_("increment of read-only member %qs"),
2808 N_("decrement of read-only member %qs")),
2809 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg
, 1))));
2811 else if (TREE_CODE (arg
) == VAR_DECL
)
2812 error (READONLY_MSG (N_("assignment of read-only variable %qs"),
2813 N_("increment of read-only variable %qs"),
2814 N_("decrement of read-only variable %qs")),
2815 IDENTIFIER_POINTER (DECL_NAME (arg
)));
2817 error (READONLY_MSG (N_("assignment of read-only location"),
2818 N_("increment of read-only location"),
2819 N_("decrement of read-only location")));
2822 /* Mark EXP saying that we need to be able to take the
2823 address of it; it should not be allocated in a register.
2824 Returns true if successful. */
2827 c_mark_addressable (tree exp
)
2832 switch (TREE_CODE (x
))
2835 if (DECL_C_BIT_FIELD (TREE_OPERAND (x
, 1)))
2838 ("cannot take address of bit-field %qD", TREE_OPERAND (x
, 1));
2842 /* ... fall through ... */
2848 x
= TREE_OPERAND (x
, 0);
2851 case COMPOUND_LITERAL_EXPR
:
2853 TREE_ADDRESSABLE (x
) = 1;
2860 if (C_DECL_REGISTER (x
)
2861 && DECL_NONLOCAL (x
))
2863 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
2866 ("global register variable %qD used in nested function", x
);
2869 pedwarn ("register variable %qD used in nested function", x
);
2871 else if (C_DECL_REGISTER (x
))
2873 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
2874 error ("address of global register variable %qD requested", x
);
2876 error ("address of register variable %qD requested", x
);
2882 TREE_ADDRESSABLE (x
) = 1;
2889 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
2892 build_conditional_expr (tree ifexp
, tree op1
, tree op2
)
2896 enum tree_code code1
;
2897 enum tree_code code2
;
2898 tree result_type
= NULL
;
2899 tree orig_op1
= op1
, orig_op2
= op2
;
2901 ifexp
= lang_hooks
.truthvalue_conversion (default_conversion (ifexp
));
2903 /* Promote both alternatives. */
2905 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
2906 op1
= default_conversion (op1
);
2907 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
2908 op2
= default_conversion (op2
);
2910 if (TREE_CODE (ifexp
) == ERROR_MARK
2911 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
2912 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
2913 return error_mark_node
;
2915 type1
= TREE_TYPE (op1
);
2916 code1
= TREE_CODE (type1
);
2917 type2
= TREE_TYPE (op2
);
2918 code2
= TREE_CODE (type2
);
2920 /* C90 does not permit non-lvalue arrays in conditional expressions.
2921 In C99 they will be pointers by now. */
2922 if (code1
== ARRAY_TYPE
|| code2
== ARRAY_TYPE
)
2924 error ("non-lvalue array in conditional expression");
2925 return error_mark_node
;
2928 /* Quickly detect the usual case where op1 and op2 have the same type
2930 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
2933 result_type
= type1
;
2935 result_type
= TYPE_MAIN_VARIANT (type1
);
2937 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
2938 || code1
== COMPLEX_TYPE
)
2939 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
2940 || code2
== COMPLEX_TYPE
))
2942 result_type
= c_common_type (type1
, type2
);
2944 /* If -Wsign-compare, warn here if type1 and type2 have
2945 different signedness. We'll promote the signed to unsigned
2946 and later code won't know it used to be different.
2947 Do this check on the original types, so that explicit casts
2948 will be considered, but default promotions won't. */
2949 if (warn_sign_compare
&& !skip_evaluation
)
2951 int unsigned_op1
= TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
2952 int unsigned_op2
= TYPE_UNSIGNED (TREE_TYPE (orig_op2
));
2954 if (unsigned_op1
^ unsigned_op2
)
2956 /* Do not warn if the result type is signed, since the
2957 signed type will only be chosen if it can represent
2958 all the values of the unsigned type. */
2959 if (!TYPE_UNSIGNED (result_type
))
2961 /* Do not warn if the signed quantity is an unsuffixed
2962 integer literal (or some static constant expression
2963 involving such literals) and it is non-negative. */
2964 else if ((unsigned_op2
&& tree_expr_nonnegative_p (op1
))
2965 || (unsigned_op1
&& tree_expr_nonnegative_p (op2
)))
2968 warning ("signed and unsigned type in conditional expression");
2972 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
2974 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
2975 pedwarn ("ISO C forbids conditional expr with only one void side");
2976 result_type
= void_type_node
;
2978 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
2980 if (comp_target_types (type1
, type2
, 1))
2981 result_type
= common_pointer_type (type1
, type2
);
2982 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
2983 && TREE_CODE (orig_op1
) != NOP_EXPR
)
2984 result_type
= qualify_type (type2
, type1
);
2985 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
2986 && TREE_CODE (orig_op2
) != NOP_EXPR
)
2987 result_type
= qualify_type (type1
, type2
);
2988 else if (VOID_TYPE_P (TREE_TYPE (type1
)))
2990 if (pedantic
&& TREE_CODE (TREE_TYPE (type2
)) == FUNCTION_TYPE
)
2991 pedwarn ("ISO C forbids conditional expr between "
2992 "%<void *%> and function pointer");
2993 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type1
),
2994 TREE_TYPE (type2
)));
2996 else if (VOID_TYPE_P (TREE_TYPE (type2
)))
2998 if (pedantic
&& TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
2999 pedwarn ("ISO C forbids conditional expr between "
3000 "%<void *%> and function pointer");
3001 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
3002 TREE_TYPE (type1
)));
3006 pedwarn ("pointer type mismatch in conditional expression");
3007 result_type
= build_pointer_type (void_type_node
);
3010 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
3012 if (!integer_zerop (op2
))
3013 pedwarn ("pointer/integer type mismatch in conditional expression");
3016 op2
= null_pointer_node
;
3018 result_type
= type1
;
3020 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3022 if (!integer_zerop (op1
))
3023 pedwarn ("pointer/integer type mismatch in conditional expression");
3026 op1
= null_pointer_node
;
3028 result_type
= type2
;
3033 if (flag_cond_mismatch
)
3034 result_type
= void_type_node
;
3037 error ("type mismatch in conditional expression");
3038 return error_mark_node
;
3042 /* Merge const and volatile flags of the incoming types. */
3044 = build_type_variant (result_type
,
3045 TREE_READONLY (op1
) || TREE_READONLY (op2
),
3046 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
3048 if (result_type
!= TREE_TYPE (op1
))
3049 op1
= convert_and_check (result_type
, op1
);
3050 if (result_type
!= TREE_TYPE (op2
))
3051 op2
= convert_and_check (result_type
, op2
);
3053 if (TREE_CODE (ifexp
) == INTEGER_CST
)
3054 return non_lvalue (integer_zerop (ifexp
) ? op2
: op1
);
3056 return fold (build3 (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
3059 /* Return a compound expression that performs two expressions and
3060 returns the value of the second of them. */
3063 build_compound_expr (tree expr1
, tree expr2
)
3065 /* Convert arrays and functions to pointers. */
3066 expr2
= default_function_array_conversion (expr2
);
3068 if (!TREE_SIDE_EFFECTS (expr1
))
3070 /* The left-hand operand of a comma expression is like an expression
3071 statement: with -Wextra or -Wunused, we should warn if it doesn't have
3072 any side-effects, unless it was explicitly cast to (void). */
3073 if (warn_unused_value
3074 && !(TREE_CODE (expr1
) == CONVERT_EXPR
3075 && VOID_TYPE_P (TREE_TYPE (expr1
))))
3076 warning ("left-hand operand of comma expression has no effect");
3079 /* With -Wunused, we should also warn if the left-hand operand does have
3080 side-effects, but computes a value which is not used. For example, in
3081 `foo() + bar(), baz()' the result of the `+' operator is not used,
3082 so we should issue a warning. */
3083 else if (warn_unused_value
)
3084 warn_if_unused_value (expr1
, input_location
);
3086 return build2 (COMPOUND_EXPR
, TREE_TYPE (expr2
), expr1
, expr2
);
3089 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3092 build_c_cast (tree type
, tree expr
)
3096 if (type
== error_mark_node
|| expr
== error_mark_node
)
3097 return error_mark_node
;
3099 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3100 only in <protocol> qualifications. But when constructing cast expressions,
3101 the protocols do matter and must be kept around. */
3102 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
3103 return build1 (NOP_EXPR
, type
, expr
);
3105 type
= TYPE_MAIN_VARIANT (type
);
3107 if (TREE_CODE (type
) == ARRAY_TYPE
)
3109 error ("cast specifies array type");
3110 return error_mark_node
;
3113 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3115 error ("cast specifies function type");
3116 return error_mark_node
;
3119 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
3123 if (TREE_CODE (type
) == RECORD_TYPE
3124 || TREE_CODE (type
) == UNION_TYPE
)
3125 pedwarn ("ISO C forbids casting nonscalar to the same type");
3128 else if (TREE_CODE (type
) == UNION_TYPE
)
3131 value
= default_function_array_conversion (value
);
3133 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3134 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
3135 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
3143 pedwarn ("ISO C forbids casts to union type");
3144 t
= digest_init (type
,
3145 build_constructor (type
,
3146 build_tree_list (field
, value
)),
3148 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
3149 TREE_INVARIANT (t
) = TREE_INVARIANT (value
);
3152 error ("cast to union type from type not present in union");
3153 return error_mark_node
;
3159 /* If casting to void, avoid the error that would come
3160 from default_conversion in the case of a non-lvalue array. */
3161 if (type
== void_type_node
)
3162 return build1 (CONVERT_EXPR
, type
, value
);
3164 /* Convert functions and arrays to pointers,
3165 but don't convert any other types. */
3166 value
= default_function_array_conversion (value
);
3167 otype
= TREE_TYPE (value
);
3169 /* Optionally warn about potentially worrisome casts. */
3172 && TREE_CODE (type
) == POINTER_TYPE
3173 && TREE_CODE (otype
) == POINTER_TYPE
)
3175 tree in_type
= type
;
3176 tree in_otype
= otype
;
3180 /* Check that the qualifiers on IN_TYPE are a superset of
3181 the qualifiers of IN_OTYPE. The outermost level of
3182 POINTER_TYPE nodes is uninteresting and we stop as soon
3183 as we hit a non-POINTER_TYPE node on either type. */
3186 in_otype
= TREE_TYPE (in_otype
);
3187 in_type
= TREE_TYPE (in_type
);
3189 /* GNU C allows cv-qualified function types. 'const'
3190 means the function is very pure, 'volatile' means it
3191 can't return. We need to warn when such qualifiers
3192 are added, not when they're taken away. */
3193 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
3194 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
3195 added
|= (TYPE_QUALS (in_type
) & ~TYPE_QUALS (in_otype
));
3197 discarded
|= (TYPE_QUALS (in_otype
) & ~TYPE_QUALS (in_type
));
3199 while (TREE_CODE (in_type
) == POINTER_TYPE
3200 && TREE_CODE (in_otype
) == POINTER_TYPE
);
3203 warning ("cast adds new qualifiers to function type");
3206 /* There are qualifiers present in IN_OTYPE that are not
3207 present in IN_TYPE. */
3208 warning ("cast discards qualifiers from pointer target type");
3211 /* Warn about possible alignment problems. */
3212 if (STRICT_ALIGNMENT
&& warn_cast_align
3213 && TREE_CODE (type
) == POINTER_TYPE
3214 && TREE_CODE (otype
) == POINTER_TYPE
3215 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
3216 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3217 /* Don't warn about opaque types, where the actual alignment
3218 restriction is unknown. */
3219 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
3220 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
3221 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
3222 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
3223 warning ("cast increases required alignment of target type");
3225 if (TREE_CODE (type
) == INTEGER_TYPE
3226 && TREE_CODE (otype
) == POINTER_TYPE
3227 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3228 && !TREE_CONSTANT (value
))
3229 warning ("cast from pointer to integer of different size");
3231 if (warn_bad_function_cast
3232 && TREE_CODE (value
) == CALL_EXPR
3233 && TREE_CODE (type
) != TREE_CODE (otype
))
3234 warning ("cast from function call of type %qT to non-matching "
3235 "type %qT", otype
, type
);
3237 if (TREE_CODE (type
) == POINTER_TYPE
3238 && TREE_CODE (otype
) == INTEGER_TYPE
3239 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3240 /* Don't warn about converting any constant. */
3241 && !TREE_CONSTANT (value
))
3242 warning ("cast to pointer from integer of different size");
3244 if (TREE_CODE (type
) == POINTER_TYPE
3245 && TREE_CODE (otype
) == POINTER_TYPE
3246 && TREE_CODE (expr
) == ADDR_EXPR
3247 && DECL_P (TREE_OPERAND (expr
, 0))
3248 && flag_strict_aliasing
&& warn_strict_aliasing
3249 && !VOID_TYPE_P (TREE_TYPE (type
)))
3251 /* Casting the address of a decl to non void pointer. Warn
3252 if the cast breaks type based aliasing. */
3253 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)))
3254 warning ("type-punning to incomplete type might break strict-aliasing rules");
3257 HOST_WIDE_INT set1
= get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
3258 HOST_WIDE_INT set2
= get_alias_set (TREE_TYPE (type
));
3260 if (!alias_sets_conflict_p (set1
, set2
))
3261 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3262 else if (warn_strict_aliasing
> 1
3263 && !alias_sets_might_conflict_p (set1
, set2
))
3264 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3268 /* If pedantic, warn for conversions between function and object
3269 pointer types, except for converting a null pointer constant
3270 to function pointer type. */
3272 && TREE_CODE (type
) == POINTER_TYPE
3273 && TREE_CODE (otype
) == POINTER_TYPE
3274 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
3275 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
3276 pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3279 && TREE_CODE (type
) == POINTER_TYPE
3280 && TREE_CODE (otype
) == POINTER_TYPE
3281 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
3282 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3283 && !(integer_zerop (value
) && TREE_TYPE (otype
) == void_type_node
3284 && TREE_CODE (expr
) != NOP_EXPR
))
3285 pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3288 value
= convert (type
, value
);
3290 /* Ignore any integer overflow caused by the cast. */
3291 if (TREE_CODE (value
) == INTEGER_CST
)
3293 if (EXPR_P (ovalue
))
3294 /* If OVALUE had overflow set, then so will VALUE, so it
3295 is safe to overwrite. */
3296 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
3298 TREE_OVERFLOW (value
) = 0;
3300 if (CONSTANT_CLASS_P (ovalue
))
3301 /* Similarly, constant_overflow cannot have become
3303 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
3307 /* Don't let a cast be an lvalue. */
3309 value
= non_lvalue (value
);
3314 /* Interpret a cast of expression EXPR to type TYPE. */
3316 c_cast_expr (struct c_type_name
*type_name
, tree expr
)
3319 int saved_wsp
= warn_strict_prototypes
;
3321 /* This avoids warnings about unprototyped casts on
3322 integers. E.g. "#define SIG_DFL (void(*)())0". */
3323 if (TREE_CODE (expr
) == INTEGER_CST
)
3324 warn_strict_prototypes
= 0;
3325 type
= groktypename (type_name
);
3326 warn_strict_prototypes
= saved_wsp
;
3328 return build_c_cast (type
, expr
);
3332 /* Build an assignment expression of lvalue LHS from value RHS.
3333 MODIFYCODE is the code for a binary operator that we use
3334 to combine the old value of LHS with RHS to get the new value.
3335 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3338 build_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
)
3342 tree lhstype
= TREE_TYPE (lhs
);
3343 tree olhstype
= lhstype
;
3345 /* Types that aren't fully specified cannot be used in assignments. */
3346 lhs
= require_complete_type (lhs
);
3348 /* Avoid duplicate error messages from operands that had errors. */
3349 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
3350 return error_mark_node
;
3352 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3353 /* Do not use STRIP_NOPS here. We do not want an enumerator
3354 whose value is 0 to count as a null pointer constant. */
3355 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3356 rhs
= TREE_OPERAND (rhs
, 0);
3360 /* If a binary op has been requested, combine the old LHS value with the RHS
3361 producing the value we should actually store into the LHS. */
3363 if (modifycode
!= NOP_EXPR
)
3365 lhs
= stabilize_reference (lhs
);
3366 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
3369 if (!lvalue_or_else (lhs
, lv_assign
))
3370 return error_mark_node
;
3372 /* Give an error for storing in something that is 'const'. */
3374 if (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
3375 || ((TREE_CODE (lhstype
) == RECORD_TYPE
3376 || TREE_CODE (lhstype
) == UNION_TYPE
)
3377 && C_TYPE_FIELDS_READONLY (lhstype
)))
3378 readonly_error (lhs
, lv_assign
);
3380 /* If storing into a structure or union member,
3381 it has probably been given type `int'.
3382 Compute the type that would go with
3383 the actual amount of storage the member occupies. */
3385 if (TREE_CODE (lhs
) == COMPONENT_REF
3386 && (TREE_CODE (lhstype
) == INTEGER_TYPE
3387 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
3388 || TREE_CODE (lhstype
) == REAL_TYPE
3389 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
3390 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
3392 /* If storing in a field that is in actuality a short or narrower than one,
3393 we must store in the field in its actual type. */
3395 if (lhstype
!= TREE_TYPE (lhs
))
3397 lhs
= copy_node (lhs
);
3398 TREE_TYPE (lhs
) = lhstype
;
3401 /* Convert new value to destination type. */
3403 newrhs
= convert_for_assignment (lhstype
, newrhs
, ic_assign
,
3404 NULL_TREE
, NULL_TREE
, 0);
3405 if (TREE_CODE (newrhs
) == ERROR_MARK
)
3406 return error_mark_node
;
3408 /* Scan operands. */
3410 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
3411 TREE_SIDE_EFFECTS (result
) = 1;
3413 /* If we got the LHS in a different type for storing in,
3414 convert the result back to the nominal type of LHS
3415 so that the value we return always has the same type
3416 as the LHS argument. */
3418 if (olhstype
== TREE_TYPE (result
))
3420 return convert_for_assignment (olhstype
, result
, ic_assign
,
3421 NULL_TREE
, NULL_TREE
, 0);
3424 /* Convert value RHS to type TYPE as preparation for an assignment
3425 to an lvalue of type TYPE.
3426 The real work of conversion is done by `convert'.
3427 The purpose of this function is to generate error messages
3428 for assignments that are not allowed in C.
3429 ERRTYPE says whether it is argument passing, assignment,
3430 initialization or return.
3432 FUNCTION is a tree for the function being called.
3433 PARMNUM is the number of the argument, for printing in error messages. */
3436 convert_for_assignment (tree type
, tree rhs
, enum impl_conv errtype
,
3437 tree fundecl
, tree function
, int parmnum
)
3439 enum tree_code codel
= TREE_CODE (type
);
3441 enum tree_code coder
;
3442 tree rname
= NULL_TREE
;
3444 if (errtype
== ic_argpass
|| errtype
== ic_argpass_nonproto
)
3447 /* Change pointer to function to the function itself for
3449 if (TREE_CODE (function
) == ADDR_EXPR
3450 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
3451 function
= TREE_OPERAND (function
, 0);
3453 /* Handle an ObjC selector specially for diagnostics. */
3454 selector
= objc_message_selector ();
3456 if (selector
&& parmnum
> 2)
3463 /* This macro is used to emit diagnostics to ensure that all format
3464 strings are complete sentences, visible to gettext and checked at
3466 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \
3471 pedwarn (AR, parmnum, rname); \
3473 case ic_argpass_nonproto: \
3474 warning (AR, parmnum, rname); \
3486 gcc_unreachable (); \
3490 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3491 /* Do not use STRIP_NOPS here. We do not want an enumerator
3492 whose value is 0 to count as a null pointer constant. */
3493 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3494 rhs
= TREE_OPERAND (rhs
, 0);
3496 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
3497 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
)
3498 rhs
= default_conversion (rhs
);
3499 else if (optimize
&& TREE_CODE (rhs
) == VAR_DECL
)
3500 rhs
= decl_constant_value_for_broken_optimization (rhs
);
3502 rhstype
= TREE_TYPE (rhs
);
3503 coder
= TREE_CODE (rhstype
);
3505 if (coder
== ERROR_MARK
)
3506 return error_mark_node
;
3508 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
3510 overflow_warning (rhs
);
3511 /* Check for Objective-C protocols. This will automatically
3512 issue a warning if there are protocol violations. No need to
3513 use the return value. */
3514 if (c_dialect_objc ())
3515 objc_comptypes (type
, rhstype
, 0);
3519 if (coder
== VOID_TYPE
)
3521 /* Except for passing an argument to an unprototyped function,
3522 this is a constraint violation. When passing an argument to
3523 an unprototyped function, it is compile-time undefined;
3524 making it a constraint in that case was rejected in
3526 error ("void value not ignored as it ought to be");
3527 return error_mark_node
;
3529 /* A type converts to a reference to it.
3530 This code doesn't fully support references, it's just for the
3531 special case of va_start and va_copy. */
3532 if (codel
== REFERENCE_TYPE
3533 && comptypes (TREE_TYPE (type
), TREE_TYPE (rhs
)) == 1)
3535 if (!lvalue_p (rhs
))
3537 error ("cannot pass rvalue to reference parameter");
3538 return error_mark_node
;
3540 if (!c_mark_addressable (rhs
))
3541 return error_mark_node
;
3542 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
3544 /* We already know that these two types are compatible, but they
3545 may not be exactly identical. In fact, `TREE_TYPE (type)' is
3546 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3547 likely to be va_list, a typedef to __builtin_va_list, which
3548 is different enough that it will cause problems later. */
3549 if (TREE_TYPE (TREE_TYPE (rhs
)) != TREE_TYPE (type
))
3550 rhs
= build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), rhs
);
3552 rhs
= build1 (NOP_EXPR
, type
, rhs
);
3555 /* Some types can interconvert without explicit casts. */
3556 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
3557 && vector_types_convertible_p (type
, TREE_TYPE (rhs
)))
3558 return convert (type
, rhs
);
3559 /* Arithmetic types all interconvert, and enum is treated like int. */
3560 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
3561 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
3562 || codel
== BOOLEAN_TYPE
)
3563 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
3564 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
3565 || coder
== BOOLEAN_TYPE
))
3566 return convert_and_check (type
, rhs
);
3568 /* Conversion to a transparent union from its member types.
3569 This applies only to function arguments. */
3570 else if (codel
== UNION_TYPE
&& TYPE_TRANSPARENT_UNION (type
)
3571 && (errtype
== ic_argpass
|| errtype
== ic_argpass_nonproto
))
3574 tree marginal_memb_type
= 0;
3576 for (memb_types
= TYPE_FIELDS (type
); memb_types
;
3577 memb_types
= TREE_CHAIN (memb_types
))
3579 tree memb_type
= TREE_TYPE (memb_types
);
3581 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
3582 TYPE_MAIN_VARIANT (rhstype
)))
3585 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
3588 if (coder
== POINTER_TYPE
)
3590 tree ttl
= TREE_TYPE (memb_type
);
3591 tree ttr
= TREE_TYPE (rhstype
);
3593 /* Any non-function converts to a [const][volatile] void *
3594 and vice versa; otherwise, targets must be the same.
3595 Meanwhile, the lhs target must have all the qualifiers of
3597 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3598 || comp_target_types (memb_type
, rhstype
, 0))
3600 /* If this type won't generate any warnings, use it. */
3601 if (TYPE_QUALS (ttl
) == TYPE_QUALS (ttr
)
3602 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
3603 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
3604 ? ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
3605 == TYPE_QUALS (ttr
))
3606 : ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
3607 == TYPE_QUALS (ttl
))))
3610 /* Keep looking for a better type, but remember this one. */
3611 if (!marginal_memb_type
)
3612 marginal_memb_type
= memb_type
;
3616 /* Can convert integer zero to any pointer type. */
3617 if (integer_zerop (rhs
)
3618 || (TREE_CODE (rhs
) == NOP_EXPR
3619 && integer_zerop (TREE_OPERAND (rhs
, 0))))
3621 rhs
= null_pointer_node
;
3626 if (memb_types
|| marginal_memb_type
)
3630 /* We have only a marginally acceptable member type;
3631 it needs a warning. */
3632 tree ttl
= TREE_TYPE (marginal_memb_type
);
3633 tree ttr
= TREE_TYPE (rhstype
);
3635 /* Const and volatile mean something different for function
3636 types, so the usual warnings are not appropriate. */
3637 if (TREE_CODE (ttr
) == FUNCTION_TYPE
3638 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
3640 /* Because const and volatile on functions are
3641 restrictions that say the function will not do
3642 certain things, it is okay to use a const or volatile
3643 function where an ordinary one is wanted, but not
3645 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
3646 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE "
3647 "makes qualified function "
3648 "pointer from unqualified"),
3649 N_("assignment makes qualified "
3650 "function pointer from "
3652 N_("initialization makes qualified "
3653 "function pointer from "
3655 N_("return makes qualified function "
3656 "pointer from unqualified"));
3658 else if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
3659 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3660 "qualifiers from pointer target type"),
3661 N_("assignment discards qualifiers "
3662 "from pointer target type"),
3663 N_("initialization discards qualifiers "
3664 "from pointer target type"),
3665 N_("return discards qualifiers from "
3666 "pointer target type"));
3669 if (pedantic
&& !DECL_IN_SYSTEM_HEADER (fundecl
))
3670 pedwarn ("ISO C prohibits argument conversion to union type");
3672 return build1 (NOP_EXPR
, type
, rhs
);
3676 /* Conversions among pointers */
3677 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
3678 && (coder
== codel
))
3680 tree ttl
= TREE_TYPE (type
);
3681 tree ttr
= TREE_TYPE (rhstype
);
3684 bool is_opaque_pointer
;
3685 int target_cmp
= 0; /* Cache comp_target_types () result. */
3687 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
3688 mvl
= TYPE_MAIN_VARIANT (mvl
);
3689 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
3690 mvr
= TYPE_MAIN_VARIANT (mvr
);
3691 /* Opaque pointers are treated like void pointers. */
3692 is_opaque_pointer
= (targetm
.vector_opaque_p (type
)
3693 || targetm
.vector_opaque_p (rhstype
))
3694 && TREE_CODE (ttl
) == VECTOR_TYPE
3695 && TREE_CODE (ttr
) == VECTOR_TYPE
;
3697 /* Any non-function converts to a [const][volatile] void *
3698 and vice versa; otherwise, targets must be the same.
3699 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
3700 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3701 || (target_cmp
= comp_target_types (type
, rhstype
, 0))
3702 || is_opaque_pointer
3703 || (c_common_unsigned_type (mvl
)
3704 == c_common_unsigned_type (mvr
)))
3707 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
3710 /* Check TREE_CODE to catch cases like (void *) (char *) 0
3711 which are not ANSI null ptr constants. */
3712 && (!integer_zerop (rhs
) || TREE_CODE (rhs
) == NOP_EXPR
)
3713 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
3714 WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of "
3715 "%qE between function pointer "
3717 N_("ISO C forbids assignment between "
3718 "function pointer and %<void *%>"),
3719 N_("ISO C forbids initialization between "
3720 "function pointer and %<void *%>"),
3721 N_("ISO C forbids return between function "
3722 "pointer and %<void *%>"));
3723 /* Const and volatile mean something different for function types,
3724 so the usual warnings are not appropriate. */
3725 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
3726 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
3728 if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
3729 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3730 "qualifiers from pointer target type"),
3731 N_("assignment discards qualifiers "
3732 "from pointer target type"),
3733 N_("initialization discards qualifiers "
3734 "from pointer target type"),
3735 N_("return discards qualifiers from "
3736 "pointer target type"));
3737 /* If this is not a case of ignoring a mismatch in signedness,
3739 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3742 /* If there is a mismatch, do warn. */
3743 else if (warn_pointer_sign
)
3744 WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument "
3745 "%d of %qE differ in signedness"),
3746 N_("pointer targets in assignment "
3747 "differ in signedness"),
3748 N_("pointer targets in initialization "
3749 "differ in signedness"),
3750 N_("pointer targets in return differ "
3753 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
3754 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
3756 /* Because const and volatile on functions are restrictions
3757 that say the function will not do certain things,
3758 it is okay to use a const or volatile function
3759 where an ordinary one is wanted, but not vice-versa. */
3760 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
3761 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3762 "qualified function pointer "
3763 "from unqualified"),
3764 N_("assignment makes qualified function "
3765 "pointer from unqualified"),
3766 N_("initialization makes qualified "
3767 "function pointer from unqualified"),
3768 N_("return makes qualified function "
3769 "pointer from unqualified"));
3773 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from "
3774 "incompatible pointer type"),
3775 N_("assignment from incompatible pointer type"),
3776 N_("initialization from incompatible "
3778 N_("return from incompatible pointer type"));
3779 return convert (type
, rhs
);
3781 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
3783 /* ??? This should not be an error when inlining calls to
3784 unprototyped functions. */
3785 error ("invalid use of non-lvalue array");
3786 return error_mark_node
;
3788 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
3790 /* An explicit constant 0 can convert to a pointer,
3791 or one that results from arithmetic, even including
3792 a cast to integer type. */
3793 if (!(TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
))
3795 !(TREE_CODE (rhs
) == NOP_EXPR
3796 && TREE_CODE (TREE_TYPE (rhs
)) == INTEGER_TYPE
3797 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == INTEGER_CST
3798 && integer_zerop (TREE_OPERAND (rhs
, 0))))
3799 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3800 "pointer from integer without a cast"),
3801 N_("assignment makes pointer from integer "
3803 N_("initialization makes pointer from "
3804 "integer without a cast"),
3805 N_("return makes pointer from integer "
3808 return convert (type
, rhs
);
3810 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
3812 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer "
3813 "from pointer without a cast"),
3814 N_("assignment makes integer from pointer "
3816 N_("initialization makes integer from pointer "
3818 N_("return makes integer from pointer "
3820 return convert (type
, rhs
);
3822 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
3823 return convert (type
, rhs
);
3828 case ic_argpass_nonproto
:
3829 /* ??? This should not be an error when inlining calls to
3830 unprototyped functions. */
3831 error ("incompatible type for argument %d of %qE", parmnum
, rname
);
3834 error ("incompatible types in assignment");
3837 error ("incompatible types in initialization");
3840 error ("incompatible types in return");
3846 return error_mark_node
;
3849 /* Convert VALUE for assignment into inlined parameter PARM. ARGNUM
3850 is used for error and waring reporting and indicates which argument
3851 is being processed. */
3854 c_convert_parm_for_inlining (tree parm
, tree value
, tree fn
, int argnum
)
3858 /* If FN was prototyped, the value has been converted already
3859 in convert_arguments. */
3860 if (!value
|| TYPE_ARG_TYPES (TREE_TYPE (fn
)))
3863 type
= TREE_TYPE (parm
);
3864 ret
= convert_for_assignment (type
, value
,
3865 ic_argpass_nonproto
, fn
,
3867 if (targetm
.calls
.promote_prototypes (TREE_TYPE (fn
))
3868 && INTEGRAL_TYPE_P (type
)
3869 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
3870 ret
= default_conversion (ret
);
3874 /* If VALUE is a compound expr all of whose expressions are constant, then
3875 return its value. Otherwise, return error_mark_node.
3877 This is for handling COMPOUND_EXPRs as initializer elements
3878 which is allowed with a warning when -pedantic is specified. */
3881 valid_compound_expr_initializer (tree value
, tree endtype
)
3883 if (TREE_CODE (value
) == COMPOUND_EXPR
)
3885 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
3887 return error_mark_node
;
3888 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
3891 else if (!initializer_constant_valid_p (value
, endtype
))
3892 return error_mark_node
;
3897 /* Perform appropriate conversions on the initial value of a variable,
3898 store it in the declaration DECL,
3899 and print any error messages that are appropriate.
3900 If the init is invalid, store an ERROR_MARK. */
3903 store_init_value (tree decl
, tree init
)
3907 /* If variable's type was invalidly declared, just ignore it. */
3909 type
= TREE_TYPE (decl
);
3910 if (TREE_CODE (type
) == ERROR_MARK
)
3913 /* Digest the specified initializer into an expression. */
3915 value
= digest_init (type
, init
, true, TREE_STATIC (decl
));
3917 /* Store the expression if valid; else report error. */
3919 if (warn_traditional
&& !in_system_header
3920 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
3921 warning ("traditional C rejects automatic aggregate initialization");
3923 DECL_INITIAL (decl
) = value
;
3925 /* ANSI wants warnings about out-of-range constant initializers. */
3926 STRIP_TYPE_NOPS (value
);
3927 constant_expression_warning (value
);
3929 /* Check if we need to set array size from compound literal size. */
3930 if (TREE_CODE (type
) == ARRAY_TYPE
3931 && TYPE_DOMAIN (type
) == 0
3932 && value
!= error_mark_node
)
3934 tree inside_init
= init
;
3936 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
3937 inside_init
= TREE_OPERAND (init
, 0);
3938 inside_init
= fold (inside_init
);
3940 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
3942 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
3944 if (TYPE_DOMAIN (TREE_TYPE (decl
)))
3946 /* For int foo[] = (int [3]){1}; we need to set array size
3947 now since later on array initializer will be just the
3948 brace enclosed list of the compound literal. */
3949 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (decl
));
3951 layout_decl (decl
, 0);
3957 /* Methods for storing and printing names for error messages. */
3959 /* Implement a spelling stack that allows components of a name to be pushed
3960 and popped. Each element on the stack is this structure. */
3972 #define SPELLING_STRING 1
3973 #define SPELLING_MEMBER 2
3974 #define SPELLING_BOUNDS 3
3976 static struct spelling
*spelling
; /* Next stack element (unused). */
3977 static struct spelling
*spelling_base
; /* Spelling stack base. */
3978 static int spelling_size
; /* Size of the spelling stack. */
3980 /* Macros to save and restore the spelling stack around push_... functions.
3981 Alternative to SAVE_SPELLING_STACK. */
3983 #define SPELLING_DEPTH() (spelling - spelling_base)
3984 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3986 /* Push an element on the spelling stack with type KIND and assign VALUE
3989 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
3991 int depth = SPELLING_DEPTH (); \
3993 if (depth >= spelling_size) \
3995 spelling_size += 10; \
3996 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
3998 RESTORE_SPELLING_DEPTH (depth); \
4001 spelling->kind = (KIND); \
4002 spelling->MEMBER = (VALUE); \
4006 /* Push STRING on the stack. Printed literally. */
4009 push_string (const char *string
)
4011 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
4014 /* Push a member name on the stack. Printed as '.' STRING. */
4017 push_member_name (tree decl
)
4019 const char *const string
4020 = DECL_NAME (decl
) ? IDENTIFIER_POINTER (DECL_NAME (decl
)) : "<anonymous>";
4021 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
4024 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4027 push_array_bounds (int bounds
)
4029 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
4032 /* Compute the maximum size in bytes of the printed spelling. */
4035 spelling_length (void)
4040 for (p
= spelling_base
; p
< spelling
; p
++)
4042 if (p
->kind
== SPELLING_BOUNDS
)
4045 size
+= strlen (p
->u
.s
) + 1;
4051 /* Print the spelling to BUFFER and return it. */
4054 print_spelling (char *buffer
)
4059 for (p
= spelling_base
; p
< spelling
; p
++)
4060 if (p
->kind
== SPELLING_BOUNDS
)
4062 sprintf (d
, "[%d]", p
->u
.i
);
4068 if (p
->kind
== SPELLING_MEMBER
)
4070 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
4077 /* Issue an error message for a bad initializer component.
4078 MSGID identifies the message.
4079 The component name is taken from the spelling stack. */
4082 error_init (const char *msgid
)
4086 error ("%s", _(msgid
));
4087 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4089 error ("(near initialization for %qs)", ofwhat
);
4092 /* Issue a pedantic warning for a bad initializer component.
4093 MSGID identifies the message.
4094 The component name is taken from the spelling stack. */
4097 pedwarn_init (const char *msgid
)
4101 pedwarn ("%s", _(msgid
));
4102 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4104 pedwarn ("(near initialization for %qs)", ofwhat
);
4107 /* Issue a warning for a bad initializer component.
4108 MSGID identifies the message.
4109 The component name is taken from the spelling stack. */
4112 warning_init (const char *msgid
)
4116 warning ("%s", _(msgid
));
4117 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4119 warning ("(near initialization for %qs)", ofwhat
);
4122 /* If TYPE is an array type and EXPR is a parenthesized string
4123 constant, warn if pedantic that EXPR is being used to initialize an
4124 object of type TYPE. */
4127 maybe_warn_string_init (tree type
, struct c_expr expr
)
4130 && TREE_CODE (type
) == ARRAY_TYPE
4131 && TREE_CODE (expr
.value
) == STRING_CST
4132 && expr
.original_code
!= STRING_CST
)
4133 pedwarn_init ("array initialized from parenthesized string constant");
4136 /* Digest the parser output INIT as an initializer for type TYPE.
4137 Return a C expression of type TYPE to represent the initial value.
4139 If INIT is a string constant, STRICT_STRING is true if it is
4140 unparenthesized or we should not warn here for it being parenthesized.
4141 For other types of INIT, STRICT_STRING is not used.
4143 REQUIRE_CONSTANT requests an error if non-constant initializers or
4144 elements are seen. */
4147 digest_init (tree type
, tree init
, bool strict_string
, int require_constant
)
4149 enum tree_code code
= TREE_CODE (type
);
4150 tree inside_init
= init
;
4152 if (type
== error_mark_node
4153 || init
== error_mark_node
4154 || TREE_TYPE (init
) == error_mark_node
)
4155 return error_mark_node
;
4157 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4158 /* Do not use STRIP_NOPS here. We do not want an enumerator
4159 whose value is 0 to count as a null pointer constant. */
4160 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
4161 inside_init
= TREE_OPERAND (init
, 0);
4163 inside_init
= fold (inside_init
);
4165 /* Initialization of an array of chars from a string constant
4166 optionally enclosed in braces. */
4168 if (code
== ARRAY_TYPE
&& inside_init
4169 && TREE_CODE (inside_init
) == STRING_CST
)
4171 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4172 /* Note that an array could be both an array of character type
4173 and an array of wchar_t if wchar_t is signed char or unsigned
4175 bool char_array
= (typ1
== char_type_node
4176 || typ1
== signed_char_type_node
4177 || typ1
== unsigned_char_type_node
);
4178 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
4179 if (char_array
|| wchar_array
)
4183 expr
.value
= inside_init
;
4184 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
4185 maybe_warn_string_init (type
, expr
);
4188 = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)))
4191 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4192 TYPE_MAIN_VARIANT (type
)))
4195 if (!wchar_array
&& !char_string
)
4197 error_init ("char-array initialized from wide string");
4198 return error_mark_node
;
4200 if (char_string
&& !char_array
)
4202 error_init ("wchar_t-array initialized from non-wide string");
4203 return error_mark_node
;
4206 TREE_TYPE (inside_init
) = type
;
4207 if (TYPE_DOMAIN (type
) != 0
4208 && TYPE_SIZE (type
) != 0
4209 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
4210 /* Subtract 1 (or sizeof (wchar_t))
4211 because it's ok to ignore the terminating null char
4212 that is counted in the length of the constant. */
4213 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
4214 TREE_STRING_LENGTH (inside_init
)
4215 - ((TYPE_PRECISION (typ1
)
4216 != TYPE_PRECISION (char_type_node
))
4217 ? (TYPE_PRECISION (wchar_type_node
)
4220 pedwarn_init ("initializer-string for array of chars is too long");
4224 else if (INTEGRAL_TYPE_P (typ1
))
4226 error_init ("array of inappropriate type initialized "
4227 "from string constant");
4228 return error_mark_node
;
4232 /* Build a VECTOR_CST from a *constant* vector constructor. If the
4233 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4234 below and handle as a constructor. */
4235 if (code
== VECTOR_TYPE
4236 && TREE_CODE (TREE_TYPE (inside_init
)) == VECTOR_TYPE
4237 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
)
4238 && TREE_CONSTANT (inside_init
))
4240 if (TREE_CODE (inside_init
) == VECTOR_CST
4241 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4242 TYPE_MAIN_VARIANT (type
)))
4245 if (TREE_CODE (inside_init
) == CONSTRUCTOR
)
4249 /* Iterate through elements and check if all constructor
4250 elements are *_CSTs. */
4251 for (link
= CONSTRUCTOR_ELTS (inside_init
);
4253 link
= TREE_CHAIN (link
))
4254 if (! CONSTANT_CLASS_P (TREE_VALUE (link
)))
4258 return build_vector (type
, CONSTRUCTOR_ELTS (inside_init
));
4262 /* Any type can be initialized
4263 from an expression of the same type, optionally with braces. */
4265 if (inside_init
&& TREE_TYPE (inside_init
) != 0
4266 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4267 TYPE_MAIN_VARIANT (type
))
4268 || (code
== ARRAY_TYPE
4269 && comptypes (TREE_TYPE (inside_init
), type
))
4270 || (code
== VECTOR_TYPE
4271 && comptypes (TREE_TYPE (inside_init
), type
))
4272 || (code
== POINTER_TYPE
4273 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
4274 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
4276 || (code
== POINTER_TYPE
4277 && TREE_CODE (TREE_TYPE (inside_init
)) == FUNCTION_TYPE
4278 && comptypes (TREE_TYPE (inside_init
),
4279 TREE_TYPE (type
)))))
4281 if (code
== POINTER_TYPE
)
4283 inside_init
= default_function_array_conversion (inside_init
);
4285 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
4287 error_init ("invalid use of non-lvalue array");
4288 return error_mark_node
;
4292 if (code
== VECTOR_TYPE
)
4293 /* Although the types are compatible, we may require a
4295 inside_init
= convert (type
, inside_init
);
4297 if (require_constant
&& !flag_isoc99
4298 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
4300 /* As an extension, allow initializing objects with static storage
4301 duration with compound literals (which are then treated just as
4302 the brace enclosed list they contain). */
4303 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
4304 inside_init
= DECL_INITIAL (decl
);
4307 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
4308 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
4310 error_init ("array initialized from non-constant array expression");
4311 return error_mark_node
;
4314 if (optimize
&& TREE_CODE (inside_init
) == VAR_DECL
)
4315 inside_init
= decl_constant_value_for_broken_optimization (inside_init
);
4317 /* Compound expressions can only occur here if -pedantic or
4318 -pedantic-errors is specified. In the later case, we always want
4319 an error. In the former case, we simply want a warning. */
4320 if (require_constant
&& pedantic
4321 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
4324 = valid_compound_expr_initializer (inside_init
,
4325 TREE_TYPE (inside_init
));
4326 if (inside_init
== error_mark_node
)
4327 error_init ("initializer element is not constant");
4329 pedwarn_init ("initializer element is not constant");
4330 if (flag_pedantic_errors
)
4331 inside_init
= error_mark_node
;
4333 else if (require_constant
4334 && !initializer_constant_valid_p (inside_init
,
4335 TREE_TYPE (inside_init
)))
4337 error_init ("initializer element is not constant");
4338 inside_init
= error_mark_node
;
4344 /* Handle scalar types, including conversions. */
4346 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
4347 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
4348 || code
== VECTOR_TYPE
)
4350 /* Note that convert_for_assignment calls default_conversion
4351 for arrays and functions. We must not call it in the
4352 case where inside_init is a null pointer constant. */
4354 = convert_for_assignment (type
, init
, ic_init
,
4355 NULL_TREE
, NULL_TREE
, 0);
4357 /* Check to see if we have already given an error message. */
4358 if (inside_init
== error_mark_node
)
4360 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
4362 error_init ("initializer element is not constant");
4363 inside_init
= error_mark_node
;
4365 else if (require_constant
4366 && !initializer_constant_valid_p (inside_init
,
4367 TREE_TYPE (inside_init
)))
4369 error_init ("initializer element is not computable at load time");
4370 inside_init
= error_mark_node
;
4376 /* Come here only for records and arrays. */
4378 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4380 error_init ("variable-sized object may not be initialized");
4381 return error_mark_node
;
4384 error_init ("invalid initializer");
4385 return error_mark_node
;
4388 /* Handle initializers that use braces. */
4390 /* Type of object we are accumulating a constructor for.
4391 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4392 static tree constructor_type
;
4394 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4396 static tree constructor_fields
;
4398 /* For an ARRAY_TYPE, this is the specified index
4399 at which to store the next element we get. */
4400 static tree constructor_index
;
4402 /* For an ARRAY_TYPE, this is the maximum index. */
4403 static tree constructor_max_index
;
4405 /* For a RECORD_TYPE, this is the first field not yet written out. */
4406 static tree constructor_unfilled_fields
;
4408 /* For an ARRAY_TYPE, this is the index of the first element
4409 not yet written out. */
4410 static tree constructor_unfilled_index
;
4412 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4413 This is so we can generate gaps between fields, when appropriate. */
4414 static tree constructor_bit_index
;
4416 /* If we are saving up the elements rather than allocating them,
4417 this is the list of elements so far (in reverse order,
4418 most recent first). */
4419 static tree constructor_elements
;
4421 /* 1 if constructor should be incrementally stored into a constructor chain,
4422 0 if all the elements should be kept in AVL tree. */
4423 static int constructor_incremental
;
4425 /* 1 if so far this constructor's elements are all compile-time constants. */
4426 static int constructor_constant
;
4428 /* 1 if so far this constructor's elements are all valid address constants. */
4429 static int constructor_simple
;
4431 /* 1 if this constructor is erroneous so far. */
4432 static int constructor_erroneous
;
4434 /* Structure for managing pending initializer elements, organized as an
4439 struct init_node
*left
, *right
;
4440 struct init_node
*parent
;
4446 /* Tree of pending elements at this constructor level.
4447 These are elements encountered out of order
4448 which belong at places we haven't reached yet in actually
4450 Will never hold tree nodes across GC runs. */
4451 static struct init_node
*constructor_pending_elts
;
4453 /* The SPELLING_DEPTH of this constructor. */
4454 static int constructor_depth
;
4456 /* DECL node for which an initializer is being read.
4457 0 means we are reading a constructor expression
4458 such as (struct foo) {...}. */
4459 static tree constructor_decl
;
4461 /* Nonzero if this is an initializer for a top-level decl. */
4462 static int constructor_top_level
;
4464 /* Nonzero if there were any member designators in this initializer. */
4465 static int constructor_designated
;
4467 /* Nesting depth of designator list. */
4468 static int designator_depth
;
4470 /* Nonzero if there were diagnosed errors in this designator list. */
4471 static int designator_errorneous
;
4474 /* This stack has a level for each implicit or explicit level of
4475 structuring in the initializer, including the outermost one. It
4476 saves the values of most of the variables above. */
4478 struct constructor_range_stack
;
4480 struct constructor_stack
4482 struct constructor_stack
*next
;
4487 tree unfilled_index
;
4488 tree unfilled_fields
;
4491 struct init_node
*pending_elts
;
4494 /* If value nonzero, this value should replace the entire
4495 constructor at this level. */
4496 struct c_expr replacement_value
;
4497 struct constructor_range_stack
*range_stack
;
4507 struct constructor_stack
*constructor_stack
;
4509 /* This stack represents designators from some range designator up to
4510 the last designator in the list. */
4512 struct constructor_range_stack
4514 struct constructor_range_stack
*next
, *prev
;
4515 struct constructor_stack
*stack
;
4522 struct constructor_range_stack
*constructor_range_stack
;
4524 /* This stack records separate initializers that are nested.
4525 Nested initializers can't happen in ANSI C, but GNU C allows them
4526 in cases like { ... (struct foo) { ... } ... }. */
4528 struct initializer_stack
4530 struct initializer_stack
*next
;
4532 struct constructor_stack
*constructor_stack
;
4533 struct constructor_range_stack
*constructor_range_stack
;
4535 struct spelling
*spelling
;
4536 struct spelling
*spelling_base
;
4539 char require_constant_value
;
4540 char require_constant_elements
;
4543 struct initializer_stack
*initializer_stack
;
4545 /* Prepare to parse and output the initializer for variable DECL. */
4548 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
)
4551 struct initializer_stack
*p
= xmalloc (sizeof (struct initializer_stack
));
4553 p
->decl
= constructor_decl
;
4554 p
->require_constant_value
= require_constant_value
;
4555 p
->require_constant_elements
= require_constant_elements
;
4556 p
->constructor_stack
= constructor_stack
;
4557 p
->constructor_range_stack
= constructor_range_stack
;
4558 p
->elements
= constructor_elements
;
4559 p
->spelling
= spelling
;
4560 p
->spelling_base
= spelling_base
;
4561 p
->spelling_size
= spelling_size
;
4562 p
->top_level
= constructor_top_level
;
4563 p
->next
= initializer_stack
;
4564 initializer_stack
= p
;
4566 constructor_decl
= decl
;
4567 constructor_designated
= 0;
4568 constructor_top_level
= top_level
;
4570 if (decl
!= 0 && decl
!= error_mark_node
)
4572 require_constant_value
= TREE_STATIC (decl
);
4573 require_constant_elements
4574 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
4575 /* For a scalar, you can always use any value to initialize,
4576 even within braces. */
4577 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
4578 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
4579 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
4580 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
4581 locus
= IDENTIFIER_POINTER (DECL_NAME (decl
));
4585 require_constant_value
= 0;
4586 require_constant_elements
= 0;
4587 locus
= "(anonymous)";
4590 constructor_stack
= 0;
4591 constructor_range_stack
= 0;
4593 missing_braces_mentioned
= 0;
4597 RESTORE_SPELLING_DEPTH (0);
4600 push_string (locus
);
4606 struct initializer_stack
*p
= initializer_stack
;
4608 /* Free the whole constructor stack of this initializer. */
4609 while (constructor_stack
)
4611 struct constructor_stack
*q
= constructor_stack
;
4612 constructor_stack
= q
->next
;
4616 gcc_assert (!constructor_range_stack
);
4618 /* Pop back to the data of the outer initializer (if any). */
4619 free (spelling_base
);
4621 constructor_decl
= p
->decl
;
4622 require_constant_value
= p
->require_constant_value
;
4623 require_constant_elements
= p
->require_constant_elements
;
4624 constructor_stack
= p
->constructor_stack
;
4625 constructor_range_stack
= p
->constructor_range_stack
;
4626 constructor_elements
= p
->elements
;
4627 spelling
= p
->spelling
;
4628 spelling_base
= p
->spelling_base
;
4629 spelling_size
= p
->spelling_size
;
4630 constructor_top_level
= p
->top_level
;
4631 initializer_stack
= p
->next
;
4635 /* Call here when we see the initializer is surrounded by braces.
4636 This is instead of a call to push_init_level;
4637 it is matched by a call to pop_init_level.
4639 TYPE is the type to initialize, for a constructor expression.
4640 For an initializer for a decl, TYPE is zero. */
4643 really_start_incremental_init (tree type
)
4645 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
4648 type
= TREE_TYPE (constructor_decl
);
4650 if (targetm
.vector_opaque_p (type
))
4651 error ("opaque vector types cannot be initialized");
4653 p
->type
= constructor_type
;
4654 p
->fields
= constructor_fields
;
4655 p
->index
= constructor_index
;
4656 p
->max_index
= constructor_max_index
;
4657 p
->unfilled_index
= constructor_unfilled_index
;
4658 p
->unfilled_fields
= constructor_unfilled_fields
;
4659 p
->bit_index
= constructor_bit_index
;
4660 p
->elements
= constructor_elements
;
4661 p
->constant
= constructor_constant
;
4662 p
->simple
= constructor_simple
;
4663 p
->erroneous
= constructor_erroneous
;
4664 p
->pending_elts
= constructor_pending_elts
;
4665 p
->depth
= constructor_depth
;
4666 p
->replacement_value
.value
= 0;
4667 p
->replacement_value
.original_code
= ERROR_MARK
;
4671 p
->incremental
= constructor_incremental
;
4672 p
->designated
= constructor_designated
;
4674 constructor_stack
= p
;
4676 constructor_constant
= 1;
4677 constructor_simple
= 1;
4678 constructor_depth
= SPELLING_DEPTH ();
4679 constructor_elements
= 0;
4680 constructor_pending_elts
= 0;
4681 constructor_type
= type
;
4682 constructor_incremental
= 1;
4683 constructor_designated
= 0;
4684 designator_depth
= 0;
4685 designator_errorneous
= 0;
4687 if (TREE_CODE (constructor_type
) == RECORD_TYPE
4688 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4690 constructor_fields
= TYPE_FIELDS (constructor_type
);
4691 /* Skip any nameless bit fields at the beginning. */
4692 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
4693 && DECL_NAME (constructor_fields
) == 0)
4694 constructor_fields
= TREE_CHAIN (constructor_fields
);
4696 constructor_unfilled_fields
= constructor_fields
;
4697 constructor_bit_index
= bitsize_zero_node
;
4699 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4701 if (TYPE_DOMAIN (constructor_type
))
4703 constructor_max_index
4704 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
4706 /* Detect non-empty initializations of zero-length arrays. */
4707 if (constructor_max_index
== NULL_TREE
4708 && TYPE_SIZE (constructor_type
))
4709 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4711 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4712 to initialize VLAs will cause a proper error; avoid tree
4713 checking errors as well by setting a safe value. */
4714 if (constructor_max_index
4715 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
4716 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4719 = convert (bitsizetype
,
4720 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
4724 constructor_index
= bitsize_zero_node
;
4725 constructor_max_index
= NULL_TREE
;
4728 constructor_unfilled_index
= constructor_index
;
4730 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
4732 /* Vectors are like simple fixed-size arrays. */
4733 constructor_max_index
=
4734 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
4735 constructor_index
= convert (bitsizetype
, bitsize_zero_node
);
4736 constructor_unfilled_index
= constructor_index
;
4740 /* Handle the case of int x = {5}; */
4741 constructor_fields
= constructor_type
;
4742 constructor_unfilled_fields
= constructor_type
;
4746 /* Push down into a subobject, for initialization.
4747 If this is for an explicit set of braces, IMPLICIT is 0.
4748 If it is because the next element belongs at a lower level,
4749 IMPLICIT is 1 (or 2 if the push is because of designator list). */
4752 push_init_level (int implicit
)
4754 struct constructor_stack
*p
;
4755 tree value
= NULL_TREE
;
4757 /* If we've exhausted any levels that didn't have braces,
4759 while (constructor_stack
->implicit
)
4761 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
4762 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4763 && constructor_fields
== 0)
4764 process_init_element (pop_init_level (1));
4765 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
4766 && constructor_max_index
4767 && tree_int_cst_lt (constructor_max_index
, constructor_index
))
4768 process_init_element (pop_init_level (1));
4773 /* Unless this is an explicit brace, we need to preserve previous
4777 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
4778 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4779 && constructor_fields
)
4780 value
= find_init_member (constructor_fields
);
4781 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4782 value
= find_init_member (constructor_index
);
4785 p
= XNEW (struct constructor_stack
);
4786 p
->type
= constructor_type
;
4787 p
->fields
= constructor_fields
;
4788 p
->index
= constructor_index
;
4789 p
->max_index
= constructor_max_index
;
4790 p
->unfilled_index
= constructor_unfilled_index
;
4791 p
->unfilled_fields
= constructor_unfilled_fields
;
4792 p
->bit_index
= constructor_bit_index
;
4793 p
->elements
= constructor_elements
;
4794 p
->constant
= constructor_constant
;
4795 p
->simple
= constructor_simple
;
4796 p
->erroneous
= constructor_erroneous
;
4797 p
->pending_elts
= constructor_pending_elts
;
4798 p
->depth
= constructor_depth
;
4799 p
->replacement_value
.value
= 0;
4800 p
->replacement_value
.original_code
= ERROR_MARK
;
4801 p
->implicit
= implicit
;
4803 p
->incremental
= constructor_incremental
;
4804 p
->designated
= constructor_designated
;
4805 p
->next
= constructor_stack
;
4807 constructor_stack
= p
;
4809 constructor_constant
= 1;
4810 constructor_simple
= 1;
4811 constructor_depth
= SPELLING_DEPTH ();
4812 constructor_elements
= 0;
4813 constructor_incremental
= 1;
4814 constructor_designated
= 0;
4815 constructor_pending_elts
= 0;
4818 p
->range_stack
= constructor_range_stack
;
4819 constructor_range_stack
= 0;
4820 designator_depth
= 0;
4821 designator_errorneous
= 0;
4824 /* Don't die if an entire brace-pair level is superfluous
4825 in the containing level. */
4826 if (constructor_type
== 0)
4828 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
4829 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4831 /* Don't die if there are extra init elts at the end. */
4832 if (constructor_fields
== 0)
4833 constructor_type
= 0;
4836 constructor_type
= TREE_TYPE (constructor_fields
);
4837 push_member_name (constructor_fields
);
4838 constructor_depth
++;
4841 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4843 constructor_type
= TREE_TYPE (constructor_type
);
4844 push_array_bounds (tree_low_cst (constructor_index
, 0));
4845 constructor_depth
++;
4848 if (constructor_type
== 0)
4850 error_init ("extra brace group at end of initializer");
4851 constructor_fields
= 0;
4852 constructor_unfilled_fields
= 0;
4856 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
4858 constructor_constant
= TREE_CONSTANT (value
);
4859 constructor_simple
= TREE_STATIC (value
);
4860 constructor_elements
= CONSTRUCTOR_ELTS (value
);
4861 if (constructor_elements
4862 && (TREE_CODE (constructor_type
) == RECORD_TYPE
4863 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
4864 set_nonincremental_init ();
4867 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
4869 missing_braces_mentioned
= 1;
4870 warning_init ("missing braces around initializer");
4873 if (TREE_CODE (constructor_type
) == RECORD_TYPE
4874 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4876 constructor_fields
= TYPE_FIELDS (constructor_type
);
4877 /* Skip any nameless bit fields at the beginning. */
4878 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
4879 && DECL_NAME (constructor_fields
) == 0)
4880 constructor_fields
= TREE_CHAIN (constructor_fields
);
4882 constructor_unfilled_fields
= constructor_fields
;
4883 constructor_bit_index
= bitsize_zero_node
;
4885 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
4887 /* Vectors are like simple fixed-size arrays. */
4888 constructor_max_index
=
4889 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
4890 constructor_index
= convert (bitsizetype
, integer_zero_node
);
4891 constructor_unfilled_index
= constructor_index
;
4893 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4895 if (TYPE_DOMAIN (constructor_type
))
4897 constructor_max_index
4898 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
4900 /* Detect non-empty initializations of zero-length arrays. */
4901 if (constructor_max_index
== NULL_TREE
4902 && TYPE_SIZE (constructor_type
))
4903 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4905 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4906 to initialize VLAs will cause a proper error; avoid tree
4907 checking errors as well by setting a safe value. */
4908 if (constructor_max_index
4909 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
4910 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4913 = convert (bitsizetype
,
4914 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
4917 constructor_index
= bitsize_zero_node
;
4919 constructor_unfilled_index
= constructor_index
;
4920 if (value
&& TREE_CODE (value
) == STRING_CST
)
4922 /* We need to split the char/wchar array into individual
4923 characters, so that we don't have to special case it
4925 set_nonincremental_init_from_string (value
);
4930 if (constructor_type
!= error_mark_node
)
4931 warning_init ("braces around scalar initializer");
4932 constructor_fields
= constructor_type
;
4933 constructor_unfilled_fields
= constructor_type
;
4937 /* At the end of an implicit or explicit brace level,
4938 finish up that level of constructor. If a single expression
4939 with redundant braces initialized that level, return the
4940 c_expr structure for that expression. Otherwise, the original_code
4941 element is set to ERROR_MARK.
4942 If we were outputting the elements as they are read, return 0 as the value
4943 from inner levels (process_init_element ignores that),
4944 but return error_mark_node as the value from the outermost level
4945 (that's what we want to put in DECL_INITIAL).
4946 Otherwise, return a CONSTRUCTOR expression as the value. */
4949 pop_init_level (int implicit
)
4951 struct constructor_stack
*p
;
4954 ret
.original_code
= ERROR_MARK
;
4958 /* When we come to an explicit close brace,
4959 pop any inner levels that didn't have explicit braces. */
4960 while (constructor_stack
->implicit
)
4961 process_init_element (pop_init_level (1));
4963 gcc_assert (!constructor_range_stack
);
4966 /* Now output all pending elements. */
4967 constructor_incremental
= 1;
4968 output_pending_init_elements (1);
4970 p
= constructor_stack
;
4972 /* Error for initializing a flexible array member, or a zero-length
4973 array member in an inappropriate context. */
4974 if (constructor_type
&& constructor_fields
4975 && TREE_CODE (constructor_type
) == ARRAY_TYPE
4976 && TYPE_DOMAIN (constructor_type
)
4977 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
4979 /* Silently discard empty initializations. The parser will
4980 already have pedwarned for empty brackets. */
4981 if (integer_zerop (constructor_unfilled_index
))
4982 constructor_type
= NULL_TREE
;
4985 gcc_assert (!TYPE_SIZE (constructor_type
));
4987 if (constructor_depth
> 2)
4988 error_init ("initialization of flexible array member in a nested context");
4990 pedwarn_init ("initialization of a flexible array member");
4992 /* We have already issued an error message for the existence
4993 of a flexible array member not at the end of the structure.
4994 Discard the initializer so that we do not abort later. */
4995 if (TREE_CHAIN (constructor_fields
) != NULL_TREE
)
4996 constructor_type
= NULL_TREE
;
5000 /* Warn when some struct elements are implicitly initialized to zero. */
5001 if (warn_missing_field_initializers
5003 && TREE_CODE (constructor_type
) == RECORD_TYPE
5004 && constructor_unfilled_fields
)
5006 /* Do not warn for flexible array members or zero-length arrays. */
5007 while (constructor_unfilled_fields
5008 && (!DECL_SIZE (constructor_unfilled_fields
)
5009 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
5010 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
5012 /* Do not warn if this level of the initializer uses member
5013 designators; it is likely to be deliberate. */
5014 if (constructor_unfilled_fields
&& !constructor_designated
)
5016 push_member_name (constructor_unfilled_fields
);
5017 warning_init ("missing initializer");
5018 RESTORE_SPELLING_DEPTH (constructor_depth
);
5022 /* Pad out the end of the structure. */
5023 if (p
->replacement_value
.value
)
5024 /* If this closes a superfluous brace pair,
5025 just pass out the element between them. */
5026 ret
= p
->replacement_value
;
5027 else if (constructor_type
== 0)
5029 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
5030 && TREE_CODE (constructor_type
) != UNION_TYPE
5031 && TREE_CODE (constructor_type
) != ARRAY_TYPE
5032 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
5034 /* A nonincremental scalar initializer--just return
5035 the element, after verifying there is just one. */
5036 if (constructor_elements
== 0)
5038 if (!constructor_erroneous
)
5039 error_init ("empty scalar initializer");
5040 ret
.value
= error_mark_node
;
5042 else if (TREE_CHAIN (constructor_elements
) != 0)
5044 error_init ("extra elements in scalar initializer");
5045 ret
.value
= TREE_VALUE (constructor_elements
);
5048 ret
.value
= TREE_VALUE (constructor_elements
);
5052 if (constructor_erroneous
)
5053 ret
.value
= error_mark_node
;
5056 ret
.value
= build_constructor (constructor_type
,
5057 nreverse (constructor_elements
));
5058 if (constructor_constant
)
5059 TREE_CONSTANT (ret
.value
) = TREE_INVARIANT (ret
.value
) = 1;
5060 if (constructor_constant
&& constructor_simple
)
5061 TREE_STATIC (ret
.value
) = 1;
5065 constructor_type
= p
->type
;
5066 constructor_fields
= p
->fields
;
5067 constructor_index
= p
->index
;
5068 constructor_max_index
= p
->max_index
;
5069 constructor_unfilled_index
= p
->unfilled_index
;
5070 constructor_unfilled_fields
= p
->unfilled_fields
;
5071 constructor_bit_index
= p
->bit_index
;
5072 constructor_elements
= p
->elements
;
5073 constructor_constant
= p
->constant
;
5074 constructor_simple
= p
->simple
;
5075 constructor_erroneous
= p
->erroneous
;
5076 constructor_incremental
= p
->incremental
;
5077 constructor_designated
= p
->designated
;
5078 constructor_pending_elts
= p
->pending_elts
;
5079 constructor_depth
= p
->depth
;
5081 constructor_range_stack
= p
->range_stack
;
5082 RESTORE_SPELLING_DEPTH (constructor_depth
);
5084 constructor_stack
= p
->next
;
5089 if (constructor_stack
== 0)
5091 ret
.value
= error_mark_node
;
5099 /* Common handling for both array range and field name designators.
5100 ARRAY argument is nonzero for array ranges. Returns zero for success. */
5103 set_designator (int array
)
5106 enum tree_code subcode
;
5108 /* Don't die if an entire brace-pair level is superfluous
5109 in the containing level. */
5110 if (constructor_type
== 0)
5113 /* If there were errors in this designator list already, bail out
5115 if (designator_errorneous
)
5118 if (!designator_depth
)
5120 gcc_assert (!constructor_range_stack
);
5122 /* Designator list starts at the level of closest explicit
5124 while (constructor_stack
->implicit
)
5125 process_init_element (pop_init_level (1));
5126 constructor_designated
= 1;
5130 switch (TREE_CODE (constructor_type
))
5134 subtype
= TREE_TYPE (constructor_fields
);
5135 if (subtype
!= error_mark_node
)
5136 subtype
= TYPE_MAIN_VARIANT (subtype
);
5139 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
5145 subcode
= TREE_CODE (subtype
);
5146 if (array
&& subcode
!= ARRAY_TYPE
)
5148 error_init ("array index in non-array initializer");
5151 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
5153 error_init ("field name not in record or union initializer");
5157 constructor_designated
= 1;
5158 push_init_level (2);
5162 /* If there are range designators in designator list, push a new designator
5163 to constructor_range_stack. RANGE_END is end of such stack range or
5164 NULL_TREE if there is no range designator at this level. */
5167 push_range_stack (tree range_end
)
5169 struct constructor_range_stack
*p
;
5171 p
= GGC_NEW (struct constructor_range_stack
);
5172 p
->prev
= constructor_range_stack
;
5174 p
->fields
= constructor_fields
;
5175 p
->range_start
= constructor_index
;
5176 p
->index
= constructor_index
;
5177 p
->stack
= constructor_stack
;
5178 p
->range_end
= range_end
;
5179 if (constructor_range_stack
)
5180 constructor_range_stack
->next
= p
;
5181 constructor_range_stack
= p
;
5184 /* Within an array initializer, specify the next index to be initialized.
5185 FIRST is that index. If LAST is nonzero, then initialize a range
5186 of indices, running from FIRST through LAST. */
5189 set_init_index (tree first
, tree last
)
5191 if (set_designator (1))
5194 designator_errorneous
= 1;
5196 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
5197 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
5199 error_init ("array index in initializer not of integer type");
5203 while ((TREE_CODE (first
) == NOP_EXPR
5204 || TREE_CODE (first
) == CONVERT_EXPR
5205 || TREE_CODE (first
) == NON_LVALUE_EXPR
)
5206 && (TYPE_MODE (TREE_TYPE (first
))
5207 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first
, 0)))))
5208 first
= TREE_OPERAND (first
, 0);
5211 while ((TREE_CODE (last
) == NOP_EXPR
5212 || TREE_CODE (last
) == CONVERT_EXPR
5213 || TREE_CODE (last
) == NON_LVALUE_EXPR
)
5214 && (TYPE_MODE (TREE_TYPE (last
))
5215 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last
, 0)))))
5216 last
= TREE_OPERAND (last
, 0);
5218 if (TREE_CODE (first
) != INTEGER_CST
)
5219 error_init ("nonconstant array index in initializer");
5220 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
5221 error_init ("nonconstant array index in initializer");
5222 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5223 error_init ("array index in non-array initializer");
5224 else if (tree_int_cst_sgn (first
) == -1)
5225 error_init ("array index in initializer exceeds array bounds");
5226 else if (constructor_max_index
5227 && tree_int_cst_lt (constructor_max_index
, first
))
5228 error_init ("array index in initializer exceeds array bounds");
5231 constructor_index
= convert (bitsizetype
, first
);
5235 if (tree_int_cst_equal (first
, last
))
5237 else if (tree_int_cst_lt (last
, first
))
5239 error_init ("empty index range in initializer");
5244 last
= convert (bitsizetype
, last
);
5245 if (constructor_max_index
!= 0
5246 && tree_int_cst_lt (constructor_max_index
, last
))
5248 error_init ("array index range in initializer exceeds array bounds");
5255 designator_errorneous
= 0;
5256 if (constructor_range_stack
|| last
)
5257 push_range_stack (last
);
5261 /* Within a struct initializer, specify the next field to be initialized. */
5264 set_init_label (tree fieldname
)
5268 if (set_designator (0))
5271 designator_errorneous
= 1;
5273 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5274 && TREE_CODE (constructor_type
) != UNION_TYPE
)
5276 error_init ("field name not in record or union initializer");
5280 for (tail
= TYPE_FIELDS (constructor_type
); tail
;
5281 tail
= TREE_CHAIN (tail
))
5283 if (DECL_NAME (tail
) == fieldname
)
5288 error ("unknown field %qs specified in initializer",
5289 IDENTIFIER_POINTER (fieldname
));
5292 constructor_fields
= tail
;
5294 designator_errorneous
= 0;
5295 if (constructor_range_stack
)
5296 push_range_stack (NULL_TREE
);
5300 /* Add a new initializer to the tree of pending initializers. PURPOSE
5301 identifies the initializer, either array index or field in a structure.
5302 VALUE is the value of that index or field. */
5305 add_pending_init (tree purpose
, tree value
)
5307 struct init_node
*p
, **q
, *r
;
5309 q
= &constructor_pending_elts
;
5312 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5317 if (tree_int_cst_lt (purpose
, p
->purpose
))
5319 else if (tree_int_cst_lt (p
->purpose
, purpose
))
5323 if (TREE_SIDE_EFFECTS (p
->value
))
5324 warning_init ("initialized field with side-effects overwritten");
5334 bitpos
= bit_position (purpose
);
5338 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5340 else if (p
->purpose
!= purpose
)
5344 if (TREE_SIDE_EFFECTS (p
->value
))
5345 warning_init ("initialized field with side-effects overwritten");
5352 r
= GGC_NEW (struct init_node
);
5353 r
->purpose
= purpose
;
5364 struct init_node
*s
;
5368 if (p
->balance
== 0)
5370 else if (p
->balance
< 0)
5377 p
->left
->parent
= p
;
5394 constructor_pending_elts
= r
;
5399 struct init_node
*t
= r
->right
;
5403 r
->right
->parent
= r
;
5408 p
->left
->parent
= p
;
5411 p
->balance
= t
->balance
< 0;
5412 r
->balance
= -(t
->balance
> 0);
5427 constructor_pending_elts
= t
;
5433 /* p->balance == +1; growth of left side balances the node. */
5438 else /* r == p->right */
5440 if (p
->balance
== 0)
5441 /* Growth propagation from right side. */
5443 else if (p
->balance
> 0)
5450 p
->right
->parent
= p
;
5467 constructor_pending_elts
= r
;
5469 else /* r->balance == -1 */
5472 struct init_node
*t
= r
->left
;
5476 r
->left
->parent
= r
;
5481 p
->right
->parent
= p
;
5484 r
->balance
= (t
->balance
< 0);
5485 p
->balance
= -(t
->balance
> 0);
5500 constructor_pending_elts
= t
;
5506 /* p->balance == -1; growth of right side balances the node. */
5517 /* Build AVL tree from a sorted chain. */
5520 set_nonincremental_init (void)
5524 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5525 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5528 for (chain
= constructor_elements
; chain
; chain
= TREE_CHAIN (chain
))
5529 add_pending_init (TREE_PURPOSE (chain
), TREE_VALUE (chain
));
5530 constructor_elements
= 0;
5531 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5533 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
5534 /* Skip any nameless bit fields at the beginning. */
5535 while (constructor_unfilled_fields
!= 0
5536 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
5537 && DECL_NAME (constructor_unfilled_fields
) == 0)
5538 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
5541 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5543 if (TYPE_DOMAIN (constructor_type
))
5544 constructor_unfilled_index
5545 = convert (bitsizetype
,
5546 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
5548 constructor_unfilled_index
= bitsize_zero_node
;
5550 constructor_incremental
= 0;
5553 /* Build AVL tree from a string constant. */
5556 set_nonincremental_init_from_string (tree str
)
5558 tree value
, purpose
, type
;
5559 HOST_WIDE_INT val
[2];
5560 const char *p
, *end
;
5561 int byte
, wchar_bytes
, charwidth
, bitpos
;
5563 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
5565 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
5566 == TYPE_PRECISION (char_type_node
))
5570 gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
5571 == TYPE_PRECISION (wchar_type_node
));
5572 wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
5574 charwidth
= TYPE_PRECISION (char_type_node
);
5575 type
= TREE_TYPE (constructor_type
);
5576 p
= TREE_STRING_POINTER (str
);
5577 end
= p
+ TREE_STRING_LENGTH (str
);
5579 for (purpose
= bitsize_zero_node
;
5580 p
< end
&& !tree_int_cst_lt (constructor_max_index
, purpose
);
5581 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
5583 if (wchar_bytes
== 1)
5585 val
[1] = (unsigned char) *p
++;
5592 for (byte
= 0; byte
< wchar_bytes
; byte
++)
5594 if (BYTES_BIG_ENDIAN
)
5595 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
5597 bitpos
= byte
* charwidth
;
5598 val
[bitpos
< HOST_BITS_PER_WIDE_INT
]
5599 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
5600 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
5604 if (!TYPE_UNSIGNED (type
))
5606 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
5607 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5609 if (val
[1] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
5611 val
[1] |= ((HOST_WIDE_INT
) -1) << bitpos
;
5615 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
5620 else if (val
[0] & (((HOST_WIDE_INT
) 1)
5621 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
5622 val
[0] |= ((HOST_WIDE_INT
) -1)
5623 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5626 value
= build_int_cst_wide (type
, val
[1], val
[0]);
5627 add_pending_init (purpose
, value
);
5630 constructor_incremental
= 0;
5633 /* Return value of FIELD in pending initializer or zero if the field was
5634 not initialized yet. */
5637 find_init_member (tree field
)
5639 struct init_node
*p
;
5641 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5643 if (constructor_incremental
5644 && tree_int_cst_lt (field
, constructor_unfilled_index
))
5645 set_nonincremental_init ();
5647 p
= constructor_pending_elts
;
5650 if (tree_int_cst_lt (field
, p
->purpose
))
5652 else if (tree_int_cst_lt (p
->purpose
, field
))
5658 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5660 tree bitpos
= bit_position (field
);
5662 if (constructor_incremental
5663 && (!constructor_unfilled_fields
5664 || tree_int_cst_lt (bitpos
,
5665 bit_position (constructor_unfilled_fields
))))
5666 set_nonincremental_init ();
5668 p
= constructor_pending_elts
;
5671 if (field
== p
->purpose
)
5673 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5679 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
5681 if (constructor_elements
5682 && TREE_PURPOSE (constructor_elements
) == field
)
5683 return TREE_VALUE (constructor_elements
);
5688 /* "Output" the next constructor element.
5689 At top level, really output it to assembler code now.
5690 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5691 TYPE is the data type that the containing data type wants here.
5692 FIELD is the field (a FIELD_DECL) or the index that this element fills.
5693 If VALUE is a string constant, STRICT_STRING is true if it is
5694 unparenthesized or we should not warn here for it being parenthesized.
5695 For other types of VALUE, STRICT_STRING is not used.
5697 PENDING if non-nil means output pending elements that belong
5698 right after this element. (PENDING is normally 1;
5699 it is 0 while outputting pending elements, to avoid recursion.) */
5702 output_init_element (tree value
, bool strict_string
, tree type
, tree field
,
5705 if (type
== error_mark_node
|| value
== error_mark_node
)
5707 constructor_erroneous
= 1;
5710 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5711 || (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5712 && !(TREE_CODE (value
) == STRING_CST
5713 && TREE_CODE (type
) == ARRAY_TYPE
5714 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
5715 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
5716 TYPE_MAIN_VARIANT (type
))))
5717 value
= default_conversion (value
);
5719 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
5720 && require_constant_value
&& !flag_isoc99
&& pending
)
5722 /* As an extension, allow initializing objects with static storage
5723 duration with compound literals (which are then treated just as
5724 the brace enclosed list they contain). */
5725 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
5726 value
= DECL_INITIAL (decl
);
5729 if (value
== error_mark_node
)
5730 constructor_erroneous
= 1;
5731 else if (!TREE_CONSTANT (value
))
5732 constructor_constant
= 0;
5733 else if (!initializer_constant_valid_p (value
, TREE_TYPE (value
))
5734 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
5735 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5736 && DECL_C_BIT_FIELD (field
)
5737 && TREE_CODE (value
) != INTEGER_CST
))
5738 constructor_simple
= 0;
5740 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
5742 if (require_constant_value
)
5744 error_init ("initializer element is not constant");
5745 value
= error_mark_node
;
5747 else if (require_constant_elements
)
5748 pedwarn ("initializer element is not computable at load time");
5751 /* If this field is empty (and not at the end of structure),
5752 don't do anything other than checking the initializer. */
5754 && (TREE_TYPE (field
) == error_mark_node
5755 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
5756 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
5757 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
5758 || TREE_CHAIN (field
)))))
5761 value
= digest_init (type
, value
, strict_string
, require_constant_value
);
5762 if (value
== error_mark_node
)
5764 constructor_erroneous
= 1;
5768 /* If this element doesn't come next in sequence,
5769 put it on constructor_pending_elts. */
5770 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
5771 && (!constructor_incremental
5772 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
5774 if (constructor_incremental
5775 && tree_int_cst_lt (field
, constructor_unfilled_index
))
5776 set_nonincremental_init ();
5778 add_pending_init (field
, value
);
5781 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5782 && (!constructor_incremental
5783 || field
!= constructor_unfilled_fields
))
5785 /* We do this for records but not for unions. In a union,
5786 no matter which field is specified, it can be initialized
5787 right away since it starts at the beginning of the union. */
5788 if (constructor_incremental
)
5790 if (!constructor_unfilled_fields
)
5791 set_nonincremental_init ();
5794 tree bitpos
, unfillpos
;
5796 bitpos
= bit_position (field
);
5797 unfillpos
= bit_position (constructor_unfilled_fields
);
5799 if (tree_int_cst_lt (bitpos
, unfillpos
))
5800 set_nonincremental_init ();
5804 add_pending_init (field
, value
);
5807 else if (TREE_CODE (constructor_type
) == UNION_TYPE
5808 && constructor_elements
)
5810 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements
)))
5811 warning_init ("initialized field with side-effects overwritten");
5813 /* We can have just one union field set. */
5814 constructor_elements
= 0;
5817 /* Otherwise, output this element either to
5818 constructor_elements or to the assembler file. */
5820 if (field
&& TREE_CODE (field
) == INTEGER_CST
)
5821 field
= copy_node (field
);
5822 constructor_elements
5823 = tree_cons (field
, value
, constructor_elements
);
5825 /* Advance the variable that indicates sequential elements output. */
5826 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5827 constructor_unfilled_index
5828 = size_binop (PLUS_EXPR
, constructor_unfilled_index
,
5830 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5832 constructor_unfilled_fields
5833 = TREE_CHAIN (constructor_unfilled_fields
);
5835 /* Skip any nameless bit fields. */
5836 while (constructor_unfilled_fields
!= 0
5837 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
5838 && DECL_NAME (constructor_unfilled_fields
) == 0)
5839 constructor_unfilled_fields
=
5840 TREE_CHAIN (constructor_unfilled_fields
);
5842 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
5843 constructor_unfilled_fields
= 0;
5845 /* Now output any pending elements which have become next. */
5847 output_pending_init_elements (0);
5850 /* Output any pending elements which have become next.
5851 As we output elements, constructor_unfilled_{fields,index}
5852 advances, which may cause other elements to become next;
5853 if so, they too are output.
5855 If ALL is 0, we return when there are
5856 no more pending elements to output now.
5858 If ALL is 1, we output space as necessary so that
5859 we can output all the pending elements. */
5862 output_pending_init_elements (int all
)
5864 struct init_node
*elt
= constructor_pending_elts
;
5869 /* Look through the whole pending tree.
5870 If we find an element that should be output now,
5871 output it. Otherwise, set NEXT to the element
5872 that comes first among those still pending. */
5877 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5879 if (tree_int_cst_equal (elt
->purpose
,
5880 constructor_unfilled_index
))
5881 output_init_element (elt
->value
, true,
5882 TREE_TYPE (constructor_type
),
5883 constructor_unfilled_index
, 0);
5884 else if (tree_int_cst_lt (constructor_unfilled_index
,
5887 /* Advance to the next smaller node. */
5892 /* We have reached the smallest node bigger than the
5893 current unfilled index. Fill the space first. */
5894 next
= elt
->purpose
;
5900 /* Advance to the next bigger node. */
5905 /* We have reached the biggest node in a subtree. Find
5906 the parent of it, which is the next bigger node. */
5907 while (elt
->parent
&& elt
->parent
->right
== elt
)
5910 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
5913 next
= elt
->purpose
;
5919 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5920 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5922 tree ctor_unfilled_bitpos
, elt_bitpos
;
5924 /* If the current record is complete we are done. */
5925 if (constructor_unfilled_fields
== 0)
5928 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
5929 elt_bitpos
= bit_position (elt
->purpose
);
5930 /* We can't compare fields here because there might be empty
5931 fields in between. */
5932 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
5934 constructor_unfilled_fields
= elt
->purpose
;
5935 output_init_element (elt
->value
, true, TREE_TYPE (elt
->purpose
),
5938 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
5940 /* Advance to the next smaller node. */
5945 /* We have reached the smallest node bigger than the
5946 current unfilled field. Fill the space first. */
5947 next
= elt
->purpose
;
5953 /* Advance to the next bigger node. */
5958 /* We have reached the biggest node in a subtree. Find
5959 the parent of it, which is the next bigger node. */
5960 while (elt
->parent
&& elt
->parent
->right
== elt
)
5964 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
5965 bit_position (elt
->purpose
))))
5967 next
= elt
->purpose
;
5975 /* Ordinarily return, but not if we want to output all
5976 and there are elements left. */
5977 if (!(all
&& next
!= 0))
5980 /* If it's not incremental, just skip over the gap, so that after
5981 jumping to retry we will output the next successive element. */
5982 if (TREE_CODE (constructor_type
) == RECORD_TYPE
5983 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5984 constructor_unfilled_fields
= next
;
5985 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5986 constructor_unfilled_index
= next
;
5988 /* ELT now points to the node in the pending tree with the next
5989 initializer to output. */
5993 /* Add one non-braced element to the current constructor level.
5994 This adjusts the current position within the constructor's type.
5995 This may also start or terminate implicit levels
5996 to handle a partly-braced initializer.
5998 Once this has found the correct level for the new element,
5999 it calls output_init_element. */
6002 process_init_element (struct c_expr value
)
6004 tree orig_value
= value
.value
;
6005 int string_flag
= orig_value
!= 0 && TREE_CODE (orig_value
) == STRING_CST
;
6006 bool strict_string
= value
.original_code
== STRING_CST
;
6008 designator_depth
= 0;
6009 designator_errorneous
= 0;
6011 /* Handle superfluous braces around string cst as in
6012 char x[] = {"foo"}; */
6015 && TREE_CODE (constructor_type
) == ARRAY_TYPE
6016 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
6017 && integer_zerop (constructor_unfilled_index
))
6019 if (constructor_stack
->replacement_value
.value
)
6020 error_init ("excess elements in char array initializer");
6021 constructor_stack
->replacement_value
= value
;
6025 if (constructor_stack
->replacement_value
.value
!= 0)
6027 error_init ("excess elements in struct initializer");
6031 /* Ignore elements of a brace group if it is entirely superfluous
6032 and has already been diagnosed. */
6033 if (constructor_type
== 0)
6036 /* If we've exhausted any levels that didn't have braces,
6038 while (constructor_stack
->implicit
)
6040 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6041 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6042 && constructor_fields
== 0)
6043 process_init_element (pop_init_level (1));
6044 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
6045 && (constructor_max_index
== 0
6046 || tree_int_cst_lt (constructor_max_index
,
6047 constructor_index
)))
6048 process_init_element (pop_init_level (1));
6053 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6054 if (constructor_range_stack
)
6056 /* If value is a compound literal and we'll be just using its
6057 content, don't put it into a SAVE_EXPR. */
6058 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
6059 || !require_constant_value
6061 value
.value
= save_expr (value
.value
);
6066 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
6069 enum tree_code fieldcode
;
6071 if (constructor_fields
== 0)
6073 pedwarn_init ("excess elements in struct initializer");
6077 fieldtype
= TREE_TYPE (constructor_fields
);
6078 if (fieldtype
!= error_mark_node
)
6079 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6080 fieldcode
= TREE_CODE (fieldtype
);
6082 /* Error for non-static initialization of a flexible array member. */
6083 if (fieldcode
== ARRAY_TYPE
6084 && !require_constant_value
6085 && TYPE_SIZE (fieldtype
) == NULL_TREE
6086 && TREE_CHAIN (constructor_fields
) == NULL_TREE
)
6088 error_init ("non-static initialization of a flexible array member");
6092 /* Accept a string constant to initialize a subarray. */
6093 if (value
.value
!= 0
6094 && fieldcode
== ARRAY_TYPE
6095 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
6097 value
.value
= orig_value
;
6098 /* Otherwise, if we have come to a subaggregate,
6099 and we don't have an element of its type, push into it. */
6100 else if (value
.value
!= 0
6101 && value
.value
!= error_mark_node
6102 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
6103 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6104 || fieldcode
== UNION_TYPE
))
6106 push_init_level (1);
6112 push_member_name (constructor_fields
);
6113 output_init_element (value
.value
, strict_string
,
6114 fieldtype
, constructor_fields
, 1);
6115 RESTORE_SPELLING_DEPTH (constructor_depth
);
6118 /* Do the bookkeeping for an element that was
6119 directly output as a constructor. */
6121 /* For a record, keep track of end position of last field. */
6122 if (DECL_SIZE (constructor_fields
))
6123 constructor_bit_index
6124 = size_binop (PLUS_EXPR
,
6125 bit_position (constructor_fields
),
6126 DECL_SIZE (constructor_fields
));
6128 /* If the current field was the first one not yet written out,
6129 it isn't now, so update. */
6130 if (constructor_unfilled_fields
== constructor_fields
)
6132 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6133 /* Skip any nameless bit fields. */
6134 while (constructor_unfilled_fields
!= 0
6135 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
6136 && DECL_NAME (constructor_unfilled_fields
) == 0)
6137 constructor_unfilled_fields
=
6138 TREE_CHAIN (constructor_unfilled_fields
);
6142 constructor_fields
= TREE_CHAIN (constructor_fields
);
6143 /* Skip any nameless bit fields at the beginning. */
6144 while (constructor_fields
!= 0
6145 && DECL_C_BIT_FIELD (constructor_fields
)
6146 && DECL_NAME (constructor_fields
) == 0)
6147 constructor_fields
= TREE_CHAIN (constructor_fields
);
6149 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
6152 enum tree_code fieldcode
;
6154 if (constructor_fields
== 0)
6156 pedwarn_init ("excess elements in union initializer");
6160 fieldtype
= TREE_TYPE (constructor_fields
);
6161 if (fieldtype
!= error_mark_node
)
6162 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6163 fieldcode
= TREE_CODE (fieldtype
);
6165 /* Warn that traditional C rejects initialization of unions.
6166 We skip the warning if the value is zero. This is done
6167 under the assumption that the zero initializer in user
6168 code appears conditioned on e.g. __STDC__ to avoid
6169 "missing initializer" warnings and relies on default
6170 initialization to zero in the traditional C case.
6171 We also skip the warning if the initializer is designated,
6172 again on the assumption that this must be conditional on
6173 __STDC__ anyway (and we've already complained about the
6174 member-designator already). */
6175 if (warn_traditional
&& !in_system_header
&& !constructor_designated
6176 && !(value
.value
&& (integer_zerop (value
.value
)
6177 || real_zerop (value
.value
))))
6178 warning ("traditional C rejects initialization of unions");
6180 /* Accept a string constant to initialize a subarray. */
6181 if (value
.value
!= 0
6182 && fieldcode
== ARRAY_TYPE
6183 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
6185 value
.value
= orig_value
;
6186 /* Otherwise, if we have come to a subaggregate,
6187 and we don't have an element of its type, push into it. */
6188 else if (value
.value
!= 0
6189 && value
.value
!= error_mark_node
6190 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
6191 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6192 || fieldcode
== UNION_TYPE
))
6194 push_init_level (1);
6200 push_member_name (constructor_fields
);
6201 output_init_element (value
.value
, strict_string
,
6202 fieldtype
, constructor_fields
, 1);
6203 RESTORE_SPELLING_DEPTH (constructor_depth
);
6206 /* Do the bookkeeping for an element that was
6207 directly output as a constructor. */
6209 constructor_bit_index
= DECL_SIZE (constructor_fields
);
6210 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6213 constructor_fields
= 0;
6215 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6217 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6218 enum tree_code eltcode
= TREE_CODE (elttype
);
6220 /* Accept a string constant to initialize a subarray. */
6221 if (value
.value
!= 0
6222 && eltcode
== ARRAY_TYPE
6223 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
6225 value
.value
= orig_value
;
6226 /* Otherwise, if we have come to a subaggregate,
6227 and we don't have an element of its type, push into it. */
6228 else if (value
.value
!= 0
6229 && value
.value
!= error_mark_node
6230 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
6231 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
6232 || eltcode
== UNION_TYPE
))
6234 push_init_level (1);
6238 if (constructor_max_index
!= 0
6239 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
6240 || integer_all_onesp (constructor_max_index
)))
6242 pedwarn_init ("excess elements in array initializer");
6246 /* Now output the actual element. */
6249 push_array_bounds (tree_low_cst (constructor_index
, 0));
6250 output_init_element (value
.value
, strict_string
,
6251 elttype
, constructor_index
, 1);
6252 RESTORE_SPELLING_DEPTH (constructor_depth
);
6256 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6259 /* If we are doing the bookkeeping for an element that was
6260 directly output as a constructor, we must update
6261 constructor_unfilled_index. */
6262 constructor_unfilled_index
= constructor_index
;
6264 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6266 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6268 /* Do a basic check of initializer size. Note that vectors
6269 always have a fixed size derived from their type. */
6270 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
6272 pedwarn_init ("excess elements in vector initializer");
6276 /* Now output the actual element. */
6278 output_init_element (value
.value
, strict_string
,
6279 elttype
, constructor_index
, 1);
6282 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6285 /* If we are doing the bookkeeping for an element that was
6286 directly output as a constructor, we must update
6287 constructor_unfilled_index. */
6288 constructor_unfilled_index
= constructor_index
;
6291 /* Handle the sole element allowed in a braced initializer
6292 for a scalar variable. */
6293 else if (constructor_type
!= error_mark_node
6294 && constructor_fields
== 0)
6296 pedwarn_init ("excess elements in scalar initializer");
6302 output_init_element (value
.value
, strict_string
,
6303 constructor_type
, NULL_TREE
, 1);
6304 constructor_fields
= 0;
6307 /* Handle range initializers either at this level or anywhere higher
6308 in the designator stack. */
6309 if (constructor_range_stack
)
6311 struct constructor_range_stack
*p
, *range_stack
;
6314 range_stack
= constructor_range_stack
;
6315 constructor_range_stack
= 0;
6316 while (constructor_stack
!= range_stack
->stack
)
6318 gcc_assert (constructor_stack
->implicit
);
6319 process_init_element (pop_init_level (1));
6321 for (p
= range_stack
;
6322 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
6325 gcc_assert (constructor_stack
->implicit
);
6326 process_init_element (pop_init_level (1));
6329 p
->index
= size_binop (PLUS_EXPR
, p
->index
, bitsize_one_node
);
6330 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
6335 constructor_index
= p
->index
;
6336 constructor_fields
= p
->fields
;
6337 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
6345 push_init_level (2);
6346 p
->stack
= constructor_stack
;
6347 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
6348 p
->index
= p
->range_start
;
6352 constructor_range_stack
= range_stack
;
6359 constructor_range_stack
= 0;
6362 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6363 (guaranteed to be 'volatile' or null) and ARGS (represented using
6364 an ASM_EXPR node). */
6366 build_asm_stmt (tree cv_qualifier
, tree args
)
6368 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
6369 ASM_VOLATILE_P (args
) = 1;
6370 return add_stmt (args
);
6373 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6374 some INPUTS, and some CLOBBERS. The latter three may be NULL.
6375 SIMPLE indicates whether there was anything at all after the
6376 string in the asm expression -- asm("blah") and asm("blah" : )
6377 are subtly different. We use a ASM_EXPR node to represent this. */
6379 build_asm_expr (tree string
, tree outputs
, tree inputs
, tree clobbers
,
6385 const char *constraint
;
6386 const char **oconstraints
;
6387 bool allows_mem
, allows_reg
, is_inout
;
6388 int ninputs
, noutputs
;
6390 ninputs
= list_length (inputs
);
6391 noutputs
= list_length (outputs
);
6392 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
6394 string
= resolve_asm_operand_names (string
, outputs
, inputs
);
6396 /* Remove output conversions that change the type but not the mode. */
6397 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
6399 tree output
= TREE_VALUE (tail
);
6401 /* ??? Really, this should not be here. Users should be using a
6402 proper lvalue, dammit. But there's a long history of using casts
6403 in the output operands. In cases like longlong.h, this becomes a
6404 primitive form of typechecking -- if the cast can be removed, then
6405 the output operand had a type of the proper width; otherwise we'll
6406 get an error. Gross, but ... */
6407 STRIP_NOPS (output
);
6409 if (!lvalue_or_else (output
, lv_asm
))
6410 output
= error_mark_node
;
6412 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
6413 oconstraints
[i
] = constraint
;
6415 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
6416 &allows_mem
, &allows_reg
, &is_inout
))
6418 /* If the operand is going to end up in memory,
6419 mark it addressable. */
6420 if (!allows_reg
&& !c_mark_addressable (output
))
6421 output
= error_mark_node
;
6424 output
= error_mark_node
;
6426 TREE_VALUE (tail
) = output
;
6429 /* Perform default conversions on array and function inputs.
6430 Don't do this for other types as it would screw up operands
6431 expected to be in memory. */
6432 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
6436 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
6437 input
= TREE_VALUE (tail
);
6439 input
= default_function_array_conversion (input
);
6441 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
6442 oconstraints
, &allows_mem
, &allows_reg
))
6444 /* If the operand is going to end up in memory,
6445 mark it addressable. */
6446 if (!allows_reg
&& allows_mem
)
6448 /* Strip the nops as we allow this case. FIXME, this really
6449 should be rejected or made deprecated. */
6451 if (!c_mark_addressable (input
))
6452 input
= error_mark_node
;
6456 input
= error_mark_node
;
6458 TREE_VALUE (tail
) = input
;
6461 args
= build_stmt (ASM_EXPR
, string
, outputs
, inputs
, clobbers
);
6463 /* Simple asm statements are treated as volatile. */
6466 ASM_VOLATILE_P (args
) = 1;
6467 ASM_INPUT_P (args
) = 1;
6473 /* Generate a goto statement to LABEL. */
6476 c_finish_goto_label (tree label
)
6478 tree decl
= lookup_label (label
);
6482 TREE_USED (decl
) = 1;
6483 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, decl
));
6486 /* Generate a computed goto statement to EXPR. */
6489 c_finish_goto_ptr (tree expr
)
6492 pedwarn ("ISO C forbids %<goto *expr;%>");
6493 expr
= convert (ptr_type_node
, expr
);
6494 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, expr
));
6497 /* Generate a C `return' statement. RETVAL is the expression for what
6498 to return, or a null pointer for `return;' with no value. */
6501 c_finish_return (tree retval
)
6503 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
6505 if (TREE_THIS_VOLATILE (current_function_decl
))
6506 warning ("function declared %<noreturn%> has a %<return%> statement");
6510 current_function_returns_null
= 1;
6511 if ((warn_return_type
|| flag_isoc99
)
6512 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
6513 pedwarn_c99 ("%<return%> with no value, in "
6514 "function returning non-void");
6516 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
6518 current_function_returns_null
= 1;
6519 if (pedantic
|| TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
6520 pedwarn ("%<return%> with a value, in function returning void");
6524 tree t
= convert_for_assignment (valtype
, retval
, ic_return
,
6525 NULL_TREE
, NULL_TREE
, 0);
6526 tree res
= DECL_RESULT (current_function_decl
);
6529 current_function_returns_value
= 1;
6530 if (t
== error_mark_node
)
6533 inner
= t
= convert (TREE_TYPE (res
), t
);
6535 /* Strip any conversions, additions, and subtractions, and see if
6536 we are returning the address of a local variable. Warn if so. */
6539 switch (TREE_CODE (inner
))
6541 case NOP_EXPR
: case NON_LVALUE_EXPR
: case CONVERT_EXPR
:
6543 inner
= TREE_OPERAND (inner
, 0);
6547 /* If the second operand of the MINUS_EXPR has a pointer
6548 type (or is converted from it), this may be valid, so
6549 don't give a warning. */
6551 tree op1
= TREE_OPERAND (inner
, 1);
6553 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
6554 && (TREE_CODE (op1
) == NOP_EXPR
6555 || TREE_CODE (op1
) == NON_LVALUE_EXPR
6556 || TREE_CODE (op1
) == CONVERT_EXPR
))
6557 op1
= TREE_OPERAND (op1
, 0);
6559 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
6562 inner
= TREE_OPERAND (inner
, 0);
6567 inner
= TREE_OPERAND (inner
, 0);
6569 while (REFERENCE_CLASS_P (inner
)
6570 && TREE_CODE (inner
) != INDIRECT_REF
)
6571 inner
= TREE_OPERAND (inner
, 0);
6574 && !DECL_EXTERNAL (inner
)
6575 && !TREE_STATIC (inner
)
6576 && DECL_CONTEXT (inner
) == current_function_decl
)
6577 warning ("function returns address of local variable");
6587 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
6590 return add_stmt (build_stmt (RETURN_EXPR
, retval
));
6594 /* The SWITCH_STMT being built. */
6597 /* The original type of the testing expression, i.e. before the
6598 default conversion is applied. */
6601 /* A splay-tree mapping the low element of a case range to the high
6602 element, or NULL_TREE if there is no high element. Used to
6603 determine whether or not a new case label duplicates an old case
6604 label. We need a tree, rather than simply a hash table, because
6605 of the GNU case range extension. */
6608 /* The next node on the stack. */
6609 struct c_switch
*next
;
6612 /* A stack of the currently active switch statements. The innermost
6613 switch statement is on the top of the stack. There is no need to
6614 mark the stack for garbage collection because it is only active
6615 during the processing of the body of a function, and we never
6616 collect at that point. */
6618 struct c_switch
*c_switch_stack
;
6620 /* Start a C switch statement, testing expression EXP. Return the new
6624 c_start_case (tree exp
)
6626 enum tree_code code
;
6627 tree type
, orig_type
= error_mark_node
;
6628 struct c_switch
*cs
;
6630 if (exp
!= error_mark_node
)
6632 code
= TREE_CODE (TREE_TYPE (exp
));
6633 orig_type
= TREE_TYPE (exp
);
6635 if (!INTEGRAL_TYPE_P (orig_type
)
6636 && code
!= ERROR_MARK
)
6638 error ("switch quantity not an integer");
6639 exp
= integer_zero_node
;
6640 orig_type
= error_mark_node
;
6644 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
6646 if (warn_traditional
&& !in_system_header
6647 && (type
== long_integer_type_node
6648 || type
== long_unsigned_type_node
))
6649 warning ("%<long%> switch expression not converted to "
6650 "%<int%> in ISO C");
6652 exp
= default_conversion (exp
);
6653 type
= TREE_TYPE (exp
);
6657 /* Add this new SWITCH_STMT to the stack. */
6658 cs
= XNEW (struct c_switch
);
6659 cs
->switch_stmt
= build_stmt (SWITCH_STMT
, exp
, NULL_TREE
, orig_type
);
6660 cs
->orig_type
= orig_type
;
6661 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
6662 cs
->next
= c_switch_stack
;
6663 c_switch_stack
= cs
;
6665 return add_stmt (cs
->switch_stmt
);
6668 /* Process a case label. */
6671 do_case (tree low_value
, tree high_value
)
6673 tree label
= NULL_TREE
;
6677 label
= c_add_case_label (c_switch_stack
->cases
,
6678 SWITCH_STMT_COND (c_switch_stack
->switch_stmt
),
6679 c_switch_stack
->orig_type
,
6680 low_value
, high_value
);
6681 if (label
== error_mark_node
)
6685 error ("case label not within a switch statement");
6687 error ("%<default%> label not within a switch statement");
6692 /* Finish the switch statement. */
6695 c_finish_case (tree body
)
6697 struct c_switch
*cs
= c_switch_stack
;
6699 SWITCH_STMT_BODY (cs
->switch_stmt
) = body
;
6701 /* Emit warnings as needed. */
6702 c_do_switch_warnings (cs
->cases
, cs
->switch_stmt
);
6704 /* Pop the stack. */
6705 c_switch_stack
= cs
->next
;
6706 splay_tree_delete (cs
->cases
);
6710 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
6711 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6712 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
6713 statement, and was not surrounded with parenthesis. */
6716 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
6717 tree else_block
, bool nested_if
)
6721 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
6722 if (warn_parentheses
&& nested_if
&& else_block
== NULL
)
6724 tree inner_if
= then_block
;
6726 /* We know from the grammar productions that there is an IF nested
6727 within THEN_BLOCK. Due to labels and c99 conditional declarations,
6728 it might not be exactly THEN_BLOCK, but should be the last
6729 non-container statement within. */
6731 switch (TREE_CODE (inner_if
))
6736 inner_if
= BIND_EXPR_BODY (inner_if
);
6738 case STATEMENT_LIST
:
6739 inner_if
= expr_last (then_block
);
6741 case TRY_FINALLY_EXPR
:
6742 case TRY_CATCH_EXPR
:
6743 inner_if
= TREE_OPERAND (inner_if
, 0);
6750 if (COND_EXPR_ELSE (inner_if
))
6751 warning ("%Hsuggest explicit braces to avoid ambiguous %<else%>",
6755 /* Diagnose ";" via the special empty statement node that we create. */
6758 if (TREE_CODE (then_block
) == NOP_EXPR
&& !TREE_TYPE (then_block
))
6761 warning ("%Hempty body in an if-statement",
6762 EXPR_LOCUS (then_block
));
6763 then_block
= alloc_stmt_list ();
6766 && TREE_CODE (else_block
) == NOP_EXPR
6767 && !TREE_TYPE (else_block
))
6769 warning ("%Hempty body in an else-statement",
6770 EXPR_LOCUS (else_block
));
6771 else_block
= alloc_stmt_list ();
6775 stmt
= build3 (COND_EXPR
, NULL_TREE
, cond
, then_block
, else_block
);
6776 SET_EXPR_LOCATION (stmt
, if_locus
);
6780 /* Emit a general-purpose loop construct. START_LOCUS is the location of
6781 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
6782 is false for DO loops. INCR is the FOR increment expression. BODY is
6783 the statement controlled by the loop. BLAB is the break label. CLAB is
6784 the continue label. Everything is allowed to be NULL. */
6787 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
6788 tree blab
, tree clab
, bool cond_is_first
)
6790 tree entry
= NULL
, exit
= NULL
, t
;
6792 /* If the condition is zero don't generate a loop construct. */
6793 if (cond
&& integer_zerop (cond
))
6797 t
= build_and_jump (&blab
);
6798 SET_EXPR_LOCATION (t
, start_locus
);
6804 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
6806 /* If we have an exit condition, then we build an IF with gotos either
6807 out of the loop, or to the top of it. If there's no exit condition,
6808 then we just build a jump back to the top. */
6809 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
6811 if (cond
&& !integer_nonzerop (cond
))
6813 /* Canonicalize the loop condition to the end. This means
6814 generating a branch to the loop condition. Reuse the
6815 continue label, if possible. */
6820 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
6821 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
6824 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
6825 SET_EXPR_LOCATION (t
, start_locus
);
6829 t
= build_and_jump (&blab
);
6830 exit
= build3 (COND_EXPR
, void_type_node
, cond
, exit
, t
);
6833 SET_EXPR_LOCATION (exit
, start_locus
);
6835 SET_EXPR_LOCATION (exit
, input_location
);
6844 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
6852 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
6856 c_finish_bc_stmt (tree
*label_p
, bool is_break
)
6859 tree label
= *label_p
;
6861 /* In switch statements break is sometimes stylistically used after
6862 a return statement. This can lead to spurious warnings about
6863 control reaching the end of a non-void function when it is
6864 inlined. Note that we are calling block_may_fallthru with
6865 language specific tree nodes; this works because
6866 block_may_fallthru returns true when given something it does not
6868 skip
= !block_may_fallthru (cur_stmt_list
);
6873 *label_p
= label
= create_artificial_label ();
6875 else if (TREE_CODE (label
) != LABEL_DECL
)
6878 error ("break statement not within loop or switch");
6880 error ("continue statement not within a loop");
6887 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
6890 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
6893 emit_side_effect_warnings (tree expr
)
6895 if (expr
== error_mark_node
)
6897 else if (!TREE_SIDE_EFFECTS (expr
))
6899 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
6900 warning ("%Hstatement with no effect",
6901 EXPR_HAS_LOCATION (expr
) ? EXPR_LOCUS (expr
) : &input_location
);
6903 else if (warn_unused_value
)
6904 warn_if_unused_value (expr
, input_location
);
6907 /* Process an expression as if it were a complete statement. Emit
6908 diagnostics, but do not call ADD_STMT. */
6911 c_process_expr_stmt (tree expr
)
6916 /* Do default conversion if safe and possibly important,
6917 in case within ({...}). */
6918 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
6919 && (flag_isoc99
|| lvalue_p (expr
)))
6920 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
6921 expr
= default_conversion (expr
);
6923 if (warn_sequence_point
)
6924 verify_sequence_points (expr
);
6926 if (TREE_TYPE (expr
) != error_mark_node
6927 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
6928 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
6929 error ("expression statement has incomplete type");
6931 /* If we're not processing a statement expression, warn about unused values.
6932 Warnings for statement expressions will be emitted later, once we figure
6933 out which is the result. */
6934 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
6935 && (extra_warnings
|| warn_unused_value
))
6936 emit_side_effect_warnings (expr
);
6938 /* If the expression is not of a type to which we cannot assign a line
6939 number, wrap the thing in a no-op NOP_EXPR. */
6940 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
6941 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
6944 SET_EXPR_LOCATION (expr
, input_location
);
6949 /* Emit an expression as a statement. */
6952 c_finish_expr_stmt (tree expr
)
6955 return add_stmt (c_process_expr_stmt (expr
));
6960 /* Do the opposite and emit a statement as an expression. To begin,
6961 create a new binding level and return it. */
6964 c_begin_stmt_expr (void)
6968 /* We must force a BLOCK for this level so that, if it is not expanded
6969 later, there is a way to turn off the entire subtree of blocks that
6970 are contained in it. */
6972 ret
= c_begin_compound_stmt (true);
6974 /* Mark the current statement list as belonging to a statement list. */
6975 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
6981 c_finish_stmt_expr (tree body
)
6983 tree last
, type
, tmp
, val
;
6986 body
= c_end_compound_stmt (body
, true);
6988 /* Locate the last statement in BODY. See c_end_compound_stmt
6989 about always returning a BIND_EXPR. */
6990 last_p
= &BIND_EXPR_BODY (body
);
6991 last
= BIND_EXPR_BODY (body
);
6994 if (TREE_CODE (last
) == STATEMENT_LIST
)
6996 tree_stmt_iterator i
;
6998 /* This can happen with degenerate cases like ({ }). No value. */
6999 if (!TREE_SIDE_EFFECTS (last
))
7002 /* If we're supposed to generate side effects warnings, process
7003 all of the statements except the last. */
7004 if (extra_warnings
|| warn_unused_value
)
7006 for (i
= tsi_start (last
); !tsi_one_before_end_p (i
); tsi_next (&i
))
7007 emit_side_effect_warnings (tsi_stmt (i
));
7010 i
= tsi_last (last
);
7011 last_p
= tsi_stmt_ptr (i
);
7015 /* If the end of the list is exception related, then the list was split
7016 by a call to push_cleanup. Continue searching. */
7017 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
7018 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
7020 last_p
= &TREE_OPERAND (last
, 0);
7022 goto continue_searching
;
7025 /* In the case that the BIND_EXPR is not necessary, return the
7026 expression out from inside it. */
7027 if (last
== error_mark_node
7028 || (last
== BIND_EXPR_BODY (body
)
7029 && BIND_EXPR_VARS (body
) == NULL
))
7032 /* Extract the type of said expression. */
7033 type
= TREE_TYPE (last
);
7035 /* If we're not returning a value at all, then the BIND_EXPR that
7036 we already have is a fine expression to return. */
7037 if (!type
|| VOID_TYPE_P (type
))
7040 /* Now that we've located the expression containing the value, it seems
7041 silly to make voidify_wrapper_expr repeat the process. Create a
7042 temporary of the appropriate type and stick it in a TARGET_EXPR. */
7043 tmp
= create_tmp_var_raw (type
, NULL
);
7045 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
7046 tree_expr_nonnegative_p giving up immediately. */
7048 if (TREE_CODE (val
) == NOP_EXPR
7049 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
7050 val
= TREE_OPERAND (val
, 0);
7052 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
7053 SET_EXPR_LOCUS (*last_p
, EXPR_LOCUS (last
));
7055 return build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
7058 /* Begin and end compound statements. This is as simple as pushing
7059 and popping new statement lists from the tree. */
7062 c_begin_compound_stmt (bool do_scope
)
7064 tree stmt
= push_stmt_list ();
7071 c_end_compound_stmt (tree stmt
, bool do_scope
)
7077 if (c_dialect_objc ())
7078 objc_clear_super_receiver ();
7079 block
= pop_scope ();
7082 stmt
= pop_stmt_list (stmt
);
7083 stmt
= c_build_bind_expr (block
, stmt
);
7085 /* If this compound statement is nested immediately inside a statement
7086 expression, then force a BIND_EXPR to be created. Otherwise we'll
7087 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
7088 STATEMENT_LISTs merge, and thus we can lose track of what statement
7091 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
7092 && TREE_CODE (stmt
) != BIND_EXPR
)
7094 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
7095 TREE_SIDE_EFFECTS (stmt
) = 1;
7101 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
7102 when the current scope is exited. EH_ONLY is true when this is not
7103 meant to apply to normal control flow transfer. */
7106 push_cleanup (tree
ARG_UNUSED (decl
), tree cleanup
, bool eh_only
)
7108 enum tree_code code
;
7112 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
7113 stmt
= build_stmt (code
, NULL
, cleanup
);
7115 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
7116 list
= push_stmt_list ();
7117 TREE_OPERAND (stmt
, 0) = list
;
7118 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
7121 /* Build a binary-operation expression without default conversions.
7122 CODE is the kind of expression to build.
7123 This function differs from `build' in several ways:
7124 the data type of the result is computed and recorded in it,
7125 warnings are generated if arg data types are invalid,
7126 special handling for addition and subtraction of pointers is known,
7127 and some optimization is done (operations on narrow ints
7128 are done in the narrower type when that gives the same result).
7129 Constant folding is also done before the result is returned.
7131 Note that the operands will never have enumeral types, or function
7132 or array types, because either they will have the default conversions
7133 performed or they have both just been converted to some other type in which
7134 the arithmetic is to be done. */
7137 build_binary_op (enum tree_code code
, tree orig_op0
, tree orig_op1
,
7141 enum tree_code code0
, code1
;
7144 /* Expression code to give to the expression when it is built.
7145 Normally this is CODE, which is what the caller asked for,
7146 but in some special cases we change it. */
7147 enum tree_code resultcode
= code
;
7149 /* Data type in which the computation is to be performed.
7150 In the simplest cases this is the common type of the arguments. */
7151 tree result_type
= NULL
;
7153 /* Nonzero means operands have already been type-converted
7154 in whatever way is necessary.
7155 Zero means they need to be converted to RESULT_TYPE. */
7158 /* Nonzero means create the expression with this type, rather than
7160 tree build_type
= 0;
7162 /* Nonzero means after finally constructing the expression
7163 convert it to this type. */
7164 tree final_type
= 0;
7166 /* Nonzero if this is an operation like MIN or MAX which can
7167 safely be computed in short if both args are promoted shorts.
7168 Also implies COMMON.
7169 -1 indicates a bitwise operation; this makes a difference
7170 in the exact conditions for when it is safe to do the operation
7171 in a narrower mode. */
7174 /* Nonzero if this is a comparison operation;
7175 if both args are promoted shorts, compare the original shorts.
7176 Also implies COMMON. */
7177 int short_compare
= 0;
7179 /* Nonzero if this is a right-shift operation, which can be computed on the
7180 original short and then promoted if the operand is a promoted short. */
7181 int short_shift
= 0;
7183 /* Nonzero means set RESULT_TYPE to the common type of the args. */
7188 op0
= default_conversion (orig_op0
);
7189 op1
= default_conversion (orig_op1
);
7197 type0
= TREE_TYPE (op0
);
7198 type1
= TREE_TYPE (op1
);
7200 /* The expression codes of the data types of the arguments tell us
7201 whether the arguments are integers, floating, pointers, etc. */
7202 code0
= TREE_CODE (type0
);
7203 code1
= TREE_CODE (type1
);
7205 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
7206 STRIP_TYPE_NOPS (op0
);
7207 STRIP_TYPE_NOPS (op1
);
7209 /* If an error was already reported for one of the arguments,
7210 avoid reporting another error. */
7212 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
7213 return error_mark_node
;
7218 /* Handle the pointer + int case. */
7219 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7220 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
7221 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
7222 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
7228 /* Subtraction of two similar pointers.
7229 We must subtract them as integers, then divide by object size. */
7230 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
7231 && comp_target_types (type0
, type1
, 1))
7232 return pointer_diff (op0
, op1
);
7233 /* Handle pointer minus int. Just like pointer plus int. */
7234 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7235 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
7244 case TRUNC_DIV_EXPR
:
7246 case FLOOR_DIV_EXPR
:
7247 case ROUND_DIV_EXPR
:
7248 case EXACT_DIV_EXPR
:
7249 /* Floating point division by zero is a legitimate way to obtain
7250 infinities and NaNs. */
7251 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
7252 warning ("division by zero");
7254 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
7255 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
7256 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
7257 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
7259 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
7260 code0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
7261 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
7262 code1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
7264 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
7265 resultcode
= RDIV_EXPR
;
7267 /* Although it would be tempting to shorten always here, that
7268 loses on some targets, since the modulo instruction is
7269 undefined if the quotient can't be represented in the
7270 computation mode. We shorten only if unsigned or if
7271 dividing by something we know != -1. */
7272 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
7273 || (TREE_CODE (op1
) == INTEGER_CST
7274 && !integer_all_onesp (op1
)));
7282 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7284 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
7288 case TRUNC_MOD_EXPR
:
7289 case FLOOR_MOD_EXPR
:
7290 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
7291 warning ("division by zero");
7293 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7295 /* Although it would be tempting to shorten always here, that loses
7296 on some targets, since the modulo instruction is undefined if the
7297 quotient can't be represented in the computation mode. We shorten
7298 only if unsigned or if dividing by something we know != -1. */
7299 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
7300 || (TREE_CODE (op1
) == INTEGER_CST
7301 && !integer_all_onesp (op1
)));
7306 case TRUTH_ANDIF_EXPR
:
7307 case TRUTH_ORIF_EXPR
:
7308 case TRUTH_AND_EXPR
:
7310 case TRUTH_XOR_EXPR
:
7311 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
7312 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
7313 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
7314 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
7316 /* Result of these operations is always an int,
7317 but that does not mean the operands should be
7318 converted to ints! */
7319 result_type
= integer_type_node
;
7320 op0
= lang_hooks
.truthvalue_conversion (op0
);
7321 op1
= lang_hooks
.truthvalue_conversion (op1
);
7326 /* Shift operations: result has same type as first operand;
7327 always convert second operand to int.
7328 Also set SHORT_SHIFT if shifting rightward. */
7331 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7333 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
7335 if (tree_int_cst_sgn (op1
) < 0)
7336 warning ("right shift count is negative");
7339 if (!integer_zerop (op1
))
7342 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
7343 warning ("right shift count >= width of type");
7347 /* Use the type of the value to be shifted. */
7348 result_type
= type0
;
7349 /* Convert the shift-count to an integer, regardless of size
7350 of value being shifted. */
7351 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
7352 op1
= convert (integer_type_node
, op1
);
7353 /* Avoid converting op1 to result_type later. */
7359 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7361 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
7363 if (tree_int_cst_sgn (op1
) < 0)
7364 warning ("left shift count is negative");
7366 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
7367 warning ("left shift count >= width of type");
7370 /* Use the type of the value to be shifted. */
7371 result_type
= type0
;
7372 /* Convert the shift-count to an integer, regardless of size
7373 of value being shifted. */
7374 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
7375 op1
= convert (integer_type_node
, op1
);
7376 /* Avoid converting op1 to result_type later. */
7383 if (warn_float_equal
&& (code0
== REAL_TYPE
|| code1
== REAL_TYPE
))
7384 warning ("comparing floating point with == or != is unsafe");
7385 /* Result of comparison is always int,
7386 but don't convert the args to int! */
7387 build_type
= integer_type_node
;
7388 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
7389 || code0
== COMPLEX_TYPE
)
7390 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
7391 || code1
== COMPLEX_TYPE
))
7393 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
7395 tree tt0
= TREE_TYPE (type0
);
7396 tree tt1
= TREE_TYPE (type1
);
7397 /* Anything compares with void *. void * compares with anything.
7398 Otherwise, the targets must be compatible
7399 and both must be object or both incomplete. */
7400 if (comp_target_types (type0
, type1
, 1))
7401 result_type
= common_pointer_type (type0
, type1
);
7402 else if (VOID_TYPE_P (tt0
))
7404 /* op0 != orig_op0 detects the case of something
7405 whose value is 0 but which isn't a valid null ptr const. */
7406 if (pedantic
&& (!integer_zerop (op0
) || op0
!= orig_op0
)
7407 && TREE_CODE (tt1
) == FUNCTION_TYPE
)
7408 pedwarn ("ISO C forbids comparison of %<void *%>"
7409 " with function pointer");
7411 else if (VOID_TYPE_P (tt1
))
7413 if (pedantic
&& (!integer_zerop (op1
) || op1
!= orig_op1
)
7414 && TREE_CODE (tt0
) == FUNCTION_TYPE
)
7415 pedwarn ("ISO C forbids comparison of %<void *%>"
7416 " with function pointer");
7419 pedwarn ("comparison of distinct pointer types lacks a cast");
7421 if (result_type
== NULL_TREE
)
7422 result_type
= ptr_type_node
;
7424 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
7425 && integer_zerop (op1
))
7426 result_type
= type0
;
7427 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
7428 && integer_zerop (op0
))
7429 result_type
= type1
;
7430 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7432 result_type
= type0
;
7433 pedwarn ("comparison between pointer and integer");
7435 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
7437 result_type
= type1
;
7438 pedwarn ("comparison between pointer and integer");
7446 build_type
= integer_type_node
;
7447 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
7448 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
7450 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
7452 if (comp_target_types (type0
, type1
, 1))
7454 result_type
= common_pointer_type (type0
, type1
);
7455 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
7456 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
7457 pedwarn ("comparison of complete and incomplete pointers");
7459 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
7460 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7464 result_type
= ptr_type_node
;
7465 pedwarn ("comparison of distinct pointer types lacks a cast");
7468 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
7469 && integer_zerop (op1
))
7471 result_type
= type0
;
7472 if (pedantic
|| extra_warnings
)
7473 pedwarn ("ordered comparison of pointer with integer zero");
7475 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
7476 && integer_zerop (op0
))
7478 result_type
= type1
;
7480 pedwarn ("ordered comparison of pointer with integer zero");
7482 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7484 result_type
= type0
;
7485 pedwarn ("comparison between pointer and integer");
7487 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
7489 result_type
= type1
;
7490 pedwarn ("comparison between pointer and integer");
7498 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
7499 return error_mark_node
;
7501 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
7502 || code0
== VECTOR_TYPE
)
7504 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
7505 || code1
== VECTOR_TYPE
))
7507 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
7509 if (shorten
|| common
|| short_compare
)
7510 result_type
= c_common_type (type0
, type1
);
7512 /* For certain operations (which identify themselves by shorten != 0)
7513 if both args were extended from the same smaller type,
7514 do the arithmetic in that type and then extend.
7516 shorten !=0 and !=1 indicates a bitwise operation.
7517 For them, this optimization is safe only if
7518 both args are zero-extended or both are sign-extended.
7519 Otherwise, we might change the result.
7520 Eg, (short)-1 | (unsigned short)-1 is (int)-1
7521 but calculated in (unsigned short) it would be (unsigned short)-1. */
7523 if (shorten
&& none_complex
)
7525 int unsigned0
, unsigned1
;
7526 tree arg0
= get_narrower (op0
, &unsigned0
);
7527 tree arg1
= get_narrower (op1
, &unsigned1
);
7528 /* UNS is 1 if the operation to be done is an unsigned one. */
7529 int uns
= TYPE_UNSIGNED (result_type
);
7532 final_type
= result_type
;
7534 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7535 but it *requires* conversion to FINAL_TYPE. */
7537 if ((TYPE_PRECISION (TREE_TYPE (op0
))
7538 == TYPE_PRECISION (TREE_TYPE (arg0
)))
7539 && TREE_TYPE (op0
) != final_type
)
7540 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
7541 if ((TYPE_PRECISION (TREE_TYPE (op1
))
7542 == TYPE_PRECISION (TREE_TYPE (arg1
)))
7543 && TREE_TYPE (op1
) != final_type
)
7544 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
7546 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
7548 /* For bitwise operations, signedness of nominal type
7549 does not matter. Consider only how operands were extended. */
7553 /* Note that in all three cases below we refrain from optimizing
7554 an unsigned operation on sign-extended args.
7555 That would not be valid. */
7557 /* Both args variable: if both extended in same way
7558 from same width, do it in that width.
7559 Do it unsigned if args were zero-extended. */
7560 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
7561 < TYPE_PRECISION (result_type
))
7562 && (TYPE_PRECISION (TREE_TYPE (arg1
))
7563 == TYPE_PRECISION (TREE_TYPE (arg0
)))
7564 && unsigned0
== unsigned1
7565 && (unsigned0
|| !uns
))
7567 = c_common_signed_or_unsigned_type
7568 (unsigned0
, c_common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
7569 else if (TREE_CODE (arg0
) == INTEGER_CST
7570 && (unsigned1
|| !uns
)
7571 && (TYPE_PRECISION (TREE_TYPE (arg1
))
7572 < TYPE_PRECISION (result_type
))
7574 = c_common_signed_or_unsigned_type (unsigned1
,
7576 int_fits_type_p (arg0
, type
)))
7578 else if (TREE_CODE (arg1
) == INTEGER_CST
7579 && (unsigned0
|| !uns
)
7580 && (TYPE_PRECISION (TREE_TYPE (arg0
))
7581 < TYPE_PRECISION (result_type
))
7583 = c_common_signed_or_unsigned_type (unsigned0
,
7585 int_fits_type_p (arg1
, type
)))
7589 /* Shifts can be shortened if shifting right. */
7594 tree arg0
= get_narrower (op0
, &unsigned_arg
);
7596 final_type
= result_type
;
7598 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
7599 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
7601 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
7602 /* We can shorten only if the shift count is less than the
7603 number of bits in the smaller type size. */
7604 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
7605 /* We cannot drop an unsigned shift after sign-extension. */
7606 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
7608 /* Do an unsigned shift if the operand was zero-extended. */
7610 = c_common_signed_or_unsigned_type (unsigned_arg
,
7612 /* Convert value-to-be-shifted to that type. */
7613 if (TREE_TYPE (op0
) != result_type
)
7614 op0
= convert (result_type
, op0
);
7619 /* Comparison operations are shortened too but differently.
7620 They identify themselves by setting short_compare = 1. */
7624 /* Don't write &op0, etc., because that would prevent op0
7625 from being kept in a register.
7626 Instead, make copies of the our local variables and
7627 pass the copies by reference, then copy them back afterward. */
7628 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
7629 enum tree_code xresultcode
= resultcode
;
7631 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
7636 op0
= xop0
, op1
= xop1
;
7638 resultcode
= xresultcode
;
7640 if (warn_sign_compare
&& skip_evaluation
== 0)
7642 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
7643 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
7644 int unsignedp0
, unsignedp1
;
7645 tree primop0
= get_narrower (op0
, &unsignedp0
);
7646 tree primop1
= get_narrower (op1
, &unsignedp1
);
7650 STRIP_TYPE_NOPS (xop0
);
7651 STRIP_TYPE_NOPS (xop1
);
7653 /* Give warnings for comparisons between signed and unsigned
7654 quantities that may fail.
7656 Do the checking based on the original operand trees, so that
7657 casts will be considered, but default promotions won't be.
7659 Do not warn if the comparison is being done in a signed type,
7660 since the signed type will only be chosen if it can represent
7661 all the values of the unsigned type. */
7662 if (!TYPE_UNSIGNED (result_type
))
7664 /* Do not warn if both operands are the same signedness. */
7665 else if (op0_signed
== op1_signed
)
7672 sop
= xop0
, uop
= xop1
;
7674 sop
= xop1
, uop
= xop0
;
7676 /* Do not warn if the signed quantity is an
7677 unsuffixed integer literal (or some static
7678 constant expression involving such literals or a
7679 conditional expression involving such literals)
7680 and it is non-negative. */
7681 if (tree_expr_nonnegative_p (sop
))
7683 /* Do not warn if the comparison is an equality operation,
7684 the unsigned quantity is an integral constant, and it
7685 would fit in the result if the result were signed. */
7686 else if (TREE_CODE (uop
) == INTEGER_CST
7687 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
7689 (uop
, c_common_signed_type (result_type
)))
7691 /* Do not warn if the unsigned quantity is an enumeration
7692 constant and its maximum value would fit in the result
7693 if the result were signed. */
7694 else if (TREE_CODE (uop
) == INTEGER_CST
7695 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
7697 (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
7698 c_common_signed_type (result_type
)))
7701 warning ("comparison between signed and unsigned");
7704 /* Warn if two unsigned values are being compared in a size
7705 larger than their original size, and one (and only one) is the
7706 result of a `~' operator. This comparison will always fail.
7708 Also warn if one operand is a constant, and the constant
7709 does not have all bits set that are set in the ~ operand
7710 when it is extended. */
7712 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
7713 != (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
7715 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
7716 primop0
= get_narrower (TREE_OPERAND (primop0
, 0),
7719 primop1
= get_narrower (TREE_OPERAND (primop1
, 0),
7722 if (host_integerp (primop0
, 0) || host_integerp (primop1
, 0))
7725 HOST_WIDE_INT constant
, mask
;
7726 int unsignedp
, bits
;
7728 if (host_integerp (primop0
, 0))
7731 unsignedp
= unsignedp1
;
7732 constant
= tree_low_cst (primop0
, 0);
7737 unsignedp
= unsignedp0
;
7738 constant
= tree_low_cst (primop1
, 0);
7741 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
7742 if (bits
< TYPE_PRECISION (result_type
)
7743 && bits
< HOST_BITS_PER_WIDE_INT
&& unsignedp
)
7745 mask
= (~(HOST_WIDE_INT
) 0) << bits
;
7746 if ((mask
& constant
) != mask
)
7747 warning ("comparison of promoted ~unsigned with constant");
7750 else if (unsignedp0
&& unsignedp1
7751 && (TYPE_PRECISION (TREE_TYPE (primop0
))
7752 < TYPE_PRECISION (result_type
))
7753 && (TYPE_PRECISION (TREE_TYPE (primop1
))
7754 < TYPE_PRECISION (result_type
)))
7755 warning ("comparison of promoted ~unsigned with unsigned");
7761 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7762 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7763 Then the expression will be built.
7764 It will be given type FINAL_TYPE if that is nonzero;
7765 otherwise, it will be given type RESULT_TYPE. */
7769 binary_op_error (code
);
7770 return error_mark_node
;
7775 if (TREE_TYPE (op0
) != result_type
)
7776 op0
= convert (result_type
, op0
);
7777 if (TREE_TYPE (op1
) != result_type
)
7778 op1
= convert (result_type
, op1
);
7780 /* This can happen if one operand has a vector type, and the other
7781 has a different type. */
7782 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
7783 return error_mark_node
;
7786 if (build_type
== NULL_TREE
)
7787 build_type
= result_type
;
7790 tree result
= build2 (resultcode
, build_type
, op0
, op1
);
7792 /* Treat expressions in initializers specially as they can't trap. */
7793 result
= require_constant_value
? fold_initializer (result
)
7796 if (final_type
!= 0)
7797 result
= convert (final_type
, result
);