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. LOC is the source
1791 location of the identifier. */
1793 build_external_ref (tree id
, int fun
, location_t loc
)
1796 tree decl
= lookup_name (id
);
1798 /* In Objective-C, an instance variable (ivar) may be preferred to
1799 whatever lookup_name() found. */
1800 decl
= objc_lookup_ivar (decl
, id
);
1802 if (decl
&& decl
!= error_mark_node
)
1805 /* Implicit function declaration. */
1806 ref
= implicitly_declare (id
);
1807 else if (decl
== error_mark_node
)
1808 /* Don't complain about something that's already been
1809 complained about. */
1810 return error_mark_node
;
1813 undeclared_variable (id
, loc
);
1814 return error_mark_node
;
1817 if (TREE_TYPE (ref
) == error_mark_node
)
1818 return error_mark_node
;
1820 if (TREE_DEPRECATED (ref
))
1821 warn_deprecated_use (ref
);
1823 if (!skip_evaluation
)
1824 assemble_external (ref
);
1825 TREE_USED (ref
) = 1;
1827 if (TREE_CODE (ref
) == FUNCTION_DECL
&& !in_alignof
)
1829 if (!in_sizeof
&& !in_typeof
)
1830 C_DECL_USED (ref
) = 1;
1831 else if (DECL_INITIAL (ref
) == 0
1832 && DECL_EXTERNAL (ref
)
1833 && !TREE_PUBLIC (ref
))
1834 record_maybe_used_decl (ref
);
1837 if (TREE_CODE (ref
) == CONST_DECL
)
1839 ref
= DECL_INITIAL (ref
);
1840 TREE_CONSTANT (ref
) = 1;
1841 TREE_INVARIANT (ref
) = 1;
1843 else if (current_function_decl
!= 0
1844 && !DECL_FILE_SCOPE_P (current_function_decl
)
1845 && (TREE_CODE (ref
) == VAR_DECL
1846 || TREE_CODE (ref
) == PARM_DECL
1847 || TREE_CODE (ref
) == FUNCTION_DECL
))
1849 tree context
= decl_function_context (ref
);
1851 if (context
!= 0 && context
!= current_function_decl
)
1852 DECL_NONLOCAL (ref
) = 1;
1858 /* Record details of decls possibly used inside sizeof or typeof. */
1859 struct maybe_used_decl
1863 /* The level seen at (in_sizeof + in_typeof). */
1865 /* The next one at this level or above, or NULL. */
1866 struct maybe_used_decl
*next
;
1869 static struct maybe_used_decl
*maybe_used_decls
;
1871 /* Record that DECL, an undefined static function reference seen
1872 inside sizeof or typeof, might be used if the operand of sizeof is
1873 a VLA type or the operand of typeof is a variably modified
1877 record_maybe_used_decl (tree decl
)
1879 struct maybe_used_decl
*t
= XOBNEW (&parser_obstack
, struct maybe_used_decl
);
1881 t
->level
= in_sizeof
+ in_typeof
;
1882 t
->next
= maybe_used_decls
;
1883 maybe_used_decls
= t
;
1886 /* Pop the stack of decls possibly used inside sizeof or typeof. If
1887 USED is false, just discard them. If it is true, mark them used
1888 (if no longer inside sizeof or typeof) or move them to the next
1889 level up (if still inside sizeof or typeof). */
1892 pop_maybe_used (bool used
)
1894 struct maybe_used_decl
*p
= maybe_used_decls
;
1895 int cur_level
= in_sizeof
+ in_typeof
;
1896 while (p
&& p
->level
> cur_level
)
1901 C_DECL_USED (p
->decl
) = 1;
1903 p
->level
= cur_level
;
1907 if (!used
|| cur_level
== 0)
1908 maybe_used_decls
= p
;
1911 /* Return the result of sizeof applied to EXPR. */
1914 c_expr_sizeof_expr (struct c_expr expr
)
1917 if (expr
.value
== error_mark_node
)
1919 ret
.value
= error_mark_node
;
1920 ret
.original_code
= ERROR_MARK
;
1921 pop_maybe_used (false);
1925 ret
.value
= c_sizeof (TREE_TYPE (expr
.value
));
1926 ret
.original_code
= ERROR_MARK
;
1927 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr
.value
)));
1932 /* Return the result of sizeof applied to T, a structure for the type
1933 name passed to sizeof (rather than the type itself). */
1936 c_expr_sizeof_type (struct c_type_name
*t
)
1940 type
= groktypename (t
);
1941 ret
.value
= c_sizeof (type
);
1942 ret
.original_code
= ERROR_MARK
;
1943 pop_maybe_used (C_TYPE_VARIABLE_SIZE (type
));
1947 /* Build a function call to function FUNCTION with parameters PARAMS.
1948 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1949 TREE_VALUE of each node is a parameter-expression.
1950 FUNCTION's data type may be a function type or a pointer-to-function. */
1953 build_function_call (tree function
, tree params
)
1955 tree fntype
, fundecl
= 0;
1956 tree coerced_params
;
1957 tree name
= NULL_TREE
, result
;
1960 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1961 STRIP_TYPE_NOPS (function
);
1963 /* Convert anything with function type to a pointer-to-function. */
1964 if (TREE_CODE (function
) == FUNCTION_DECL
)
1966 name
= DECL_NAME (function
);
1968 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1969 (because calling an inline function does not mean the function
1970 needs to be separately compiled). */
1971 fntype
= build_type_variant (TREE_TYPE (function
),
1972 TREE_READONLY (function
),
1973 TREE_THIS_VOLATILE (function
));
1975 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
1978 function
= default_conversion (function
);
1980 fntype
= TREE_TYPE (function
);
1982 if (TREE_CODE (fntype
) == ERROR_MARK
)
1983 return error_mark_node
;
1985 if (!(TREE_CODE (fntype
) == POINTER_TYPE
1986 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
1988 error ("called object %qE is not a function", function
);
1989 return error_mark_node
;
1992 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
1993 current_function_returns_abnormally
= 1;
1995 /* fntype now gets the type of function pointed to. */
1996 fntype
= TREE_TYPE (fntype
);
1998 /* Check that the function is called through a compatible prototype.
1999 If it is not, replace the call by a trap, wrapped up in a compound
2000 expression if necessary. This has the nice side-effect to prevent
2001 the tree-inliner from generating invalid assignment trees which may
2002 blow up in the RTL expander later.
2004 ??? This doesn't work for Objective-C because objc_comptypes
2005 refuses to compare function prototypes, yet the compiler appears
2006 to build calls that are flagged as invalid by C's comptypes. */
2007 if (!c_dialect_objc ()
2008 && TREE_CODE (function
) == NOP_EXPR
2009 && TREE_CODE (tem
= TREE_OPERAND (function
, 0)) == ADDR_EXPR
2010 && TREE_CODE (tem
= TREE_OPERAND (tem
, 0)) == FUNCTION_DECL
2011 && !comptypes (fntype
, TREE_TYPE (tem
)))
2013 tree return_type
= TREE_TYPE (fntype
);
2014 tree trap
= build_function_call (built_in_decls
[BUILT_IN_TRAP
],
2017 /* This situation leads to run-time undefined behavior. We can't,
2018 therefore, simply error unless we can prove that all possible
2019 executions of the program must execute the code. */
2020 warning ("function called through a non-compatible type");
2022 /* We can, however, treat "undefined" any way we please.
2023 Call abort to encourage the user to fix the program. */
2024 inform ("if this code is reached, the program will abort");
2026 if (VOID_TYPE_P (return_type
))
2032 if (AGGREGATE_TYPE_P (return_type
))
2033 rhs
= build_compound_literal (return_type
,
2034 build_constructor (return_type
,
2037 rhs
= fold (build1 (NOP_EXPR
, return_type
, integer_zero_node
));
2039 return build2 (COMPOUND_EXPR
, return_type
, trap
, rhs
);
2043 /* Convert the parameters to the types declared in the
2044 function prototype, or apply default promotions. */
2047 = convert_arguments (TYPE_ARG_TYPES (fntype
), params
, function
, fundecl
);
2049 if (coerced_params
== error_mark_node
)
2050 return error_mark_node
;
2052 /* Check that the arguments to the function are valid. */
2054 check_function_arguments (TYPE_ATTRIBUTES (fntype
), coerced_params
);
2056 result
= build3 (CALL_EXPR
, TREE_TYPE (fntype
),
2057 function
, coerced_params
, NULL_TREE
);
2058 TREE_SIDE_EFFECTS (result
) = 1;
2060 if (require_constant_value
)
2062 result
= fold_initializer (result
);
2064 if (TREE_CONSTANT (result
)
2065 && (name
== NULL_TREE
2066 || strncmp (IDENTIFIER_POINTER (name
), "__builtin_", 10) != 0))
2067 pedwarn_init ("initializer element is not constant");
2070 result
= fold (result
);
2072 if (VOID_TYPE_P (TREE_TYPE (result
)))
2074 return require_complete_type (result
);
2077 /* Convert the argument expressions in the list VALUES
2078 to the types in the list TYPELIST. The result is a list of converted
2079 argument expressions, unless there are too few arguments in which
2080 case it is error_mark_node.
2082 If TYPELIST is exhausted, or when an element has NULL as its type,
2083 perform the default conversions.
2085 PARMLIST is the chain of parm decls for the function being called.
2086 It may be 0, if that info is not available.
2087 It is used only for generating error messages.
2089 FUNCTION is a tree for the called function. It is used only for
2090 error messages, where it is formatted with %qE.
2092 This is also where warnings about wrong number of args are generated.
2094 Both VALUES and the returned value are chains of TREE_LIST nodes
2095 with the elements of the list in the TREE_VALUE slots of those nodes. */
2098 convert_arguments (tree typelist
, tree values
, tree function
, tree fundecl
)
2100 tree typetail
, valtail
;
2105 /* Change pointer to function to the function itself for
2107 if (TREE_CODE (function
) == ADDR_EXPR
2108 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
2109 function
= TREE_OPERAND (function
, 0);
2111 /* Handle an ObjC selector specially for diagnostics. */
2112 selector
= objc_message_selector ();
2114 /* Scan the given expressions and types, producing individual
2115 converted arguments and pushing them on RESULT in reverse order. */
2117 for (valtail
= values
, typetail
= typelist
, parmnum
= 0;
2119 valtail
= TREE_CHAIN (valtail
), parmnum
++)
2121 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2122 tree val
= TREE_VALUE (valtail
);
2123 tree rname
= function
;
2124 int argnum
= parmnum
+ 1;
2125 const char *invalid_func_diag
;
2127 if (type
== void_type_node
)
2129 error ("too many arguments to function %qE", function
);
2133 if (selector
&& argnum
> 2)
2139 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
2140 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
2141 to convert automatically to a pointer. */
2142 if (TREE_CODE (val
) == NON_LVALUE_EXPR
)
2143 val
= TREE_OPERAND (val
, 0);
2145 val
= default_function_array_conversion (val
);
2147 val
= require_complete_type (val
);
2151 /* Formal parm type is specified by a function prototype. */
2154 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
2156 error ("type of formal parameter %d is incomplete", parmnum
+ 1);
2161 /* Optionally warn about conversions that
2162 differ from the default conversions. */
2163 if (warn_conversion
|| warn_traditional
)
2165 unsigned int formal_prec
= TYPE_PRECISION (type
);
2167 if (INTEGRAL_TYPE_P (type
)
2168 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2169 warning ("passing argument %d of %qE as integer "
2170 "rather than floating due to prototype",
2172 if (INTEGRAL_TYPE_P (type
)
2173 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
2174 warning ("passing argument %d of %qE as integer "
2175 "rather than complex due to prototype",
2177 else if (TREE_CODE (type
) == COMPLEX_TYPE
2178 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2179 warning ("passing argument %d of %qE as complex "
2180 "rather than floating due to prototype",
2182 else if (TREE_CODE (type
) == REAL_TYPE
2183 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2184 warning ("passing argument %d of %qE as floating "
2185 "rather than integer due to prototype",
2187 else if (TREE_CODE (type
) == COMPLEX_TYPE
2188 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2189 warning ("passing argument %d of %qE as complex "
2190 "rather than integer due to prototype",
2192 else if (TREE_CODE (type
) == REAL_TYPE
2193 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
2194 warning ("passing argument %d of %qE as floating "
2195 "rather than complex due to prototype",
2197 /* ??? At some point, messages should be written about
2198 conversions between complex types, but that's too messy
2200 else if (TREE_CODE (type
) == REAL_TYPE
2201 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
2203 /* Warn if any argument is passed as `float',
2204 since without a prototype it would be `double'. */
2205 if (formal_prec
== TYPE_PRECISION (float_type_node
))
2206 warning ("passing argument %d of %qE as %<float%> "
2207 "rather than %<double%> due to prototype",
2210 /* Detect integer changing in width or signedness.
2211 These warnings are only activated with
2212 -Wconversion, not with -Wtraditional. */
2213 else if (warn_conversion
&& INTEGRAL_TYPE_P (type
)
2214 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
2216 tree would_have_been
= default_conversion (val
);
2217 tree type1
= TREE_TYPE (would_have_been
);
2219 if (TREE_CODE (type
) == ENUMERAL_TYPE
2220 && (TYPE_MAIN_VARIANT (type
)
2221 == TYPE_MAIN_VARIANT (TREE_TYPE (val
))))
2222 /* No warning if function asks for enum
2223 and the actual arg is that enum type. */
2225 else if (formal_prec
!= TYPE_PRECISION (type1
))
2226 warning ("passing argument %d of %qE with different "
2227 "width due to prototype", argnum
, rname
);
2228 else if (TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (type1
))
2230 /* Don't complain if the formal parameter type
2231 is an enum, because we can't tell now whether
2232 the value was an enum--even the same enum. */
2233 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2235 else if (TREE_CODE (val
) == INTEGER_CST
2236 && int_fits_type_p (val
, type
))
2237 /* Change in signedness doesn't matter
2238 if a constant value is unaffected. */
2240 /* Likewise for a constant in a NOP_EXPR. */
2241 else if (TREE_CODE (val
) == NOP_EXPR
2242 && TREE_CODE (TREE_OPERAND (val
, 0)) == INTEGER_CST
2243 && int_fits_type_p (TREE_OPERAND (val
, 0), type
))
2245 /* If the value is extended from a narrower
2246 unsigned type, it doesn't matter whether we
2247 pass it as signed or unsigned; the value
2248 certainly is the same either way. */
2249 else if (TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
)
2250 && TYPE_UNSIGNED (TREE_TYPE (val
)))
2252 else if (TYPE_UNSIGNED (type
))
2253 warning ("passing argument %d of %qE as unsigned "
2254 "due to prototype", argnum
, rname
);
2256 warning ("passing argument %d of %qE as signed "
2257 "due to prototype", argnum
, rname
);
2261 parmval
= convert_for_assignment (type
, val
, ic_argpass
,
2265 if (targetm
.calls
.promote_prototypes (fundecl
? TREE_TYPE (fundecl
) : 0)
2266 && INTEGRAL_TYPE_P (type
)
2267 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
2268 parmval
= default_conversion (parmval
);
2270 result
= tree_cons (NULL_TREE
, parmval
, result
);
2272 else if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
2273 && (TYPE_PRECISION (TREE_TYPE (val
))
2274 < TYPE_PRECISION (double_type_node
)))
2275 /* Convert `float' to `double'. */
2276 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
2277 else if ((invalid_func_diag
=
2278 targetm
.calls
.invalid_arg_for_unprototyped_fn (typelist
, fundecl
, val
)))
2280 error (invalid_func_diag
);
2281 return error_mark_node
;
2284 /* Convert `short' and `char' to full-size `int'. */
2285 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
2288 typetail
= TREE_CHAIN (typetail
);
2291 if (typetail
!= 0 && TREE_VALUE (typetail
) != void_type_node
)
2293 error ("too few arguments to function %qE", function
);
2294 return error_mark_node
;
2297 return nreverse (result
);
2300 /* This is the entry point used by the parser
2301 for binary operators in the input.
2302 In addition to constructing the expression,
2303 we check for operands that were written with other binary operators
2304 in a way that is likely to confuse the user. */
2307 parser_build_binary_op (enum tree_code code
, struct c_expr arg1
,
2310 struct c_expr result
;
2312 enum tree_code code1
= arg1
.original_code
;
2313 enum tree_code code2
= arg2
.original_code
;
2315 result
.value
= build_binary_op (code
, arg1
.value
, arg2
.value
, 1);
2316 result
.original_code
= code
;
2318 if (TREE_CODE (result
.value
) == ERROR_MARK
)
2321 /* Check for cases such as x+y<<z which users are likely
2323 if (warn_parentheses
)
2325 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
2327 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2328 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2329 warning ("suggest parentheses around + or - inside shift");
2332 if (code
== TRUTH_ORIF_EXPR
)
2334 if (code1
== TRUTH_ANDIF_EXPR
2335 || code2
== TRUTH_ANDIF_EXPR
)
2336 warning ("suggest parentheses around && within ||");
2339 if (code
== BIT_IOR_EXPR
)
2341 if (code1
== BIT_AND_EXPR
|| code1
== BIT_XOR_EXPR
2342 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2343 || code2
== BIT_AND_EXPR
|| code2
== BIT_XOR_EXPR
2344 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2345 warning ("suggest parentheses around arithmetic in operand of |");
2346 /* Check cases like x|y==z */
2347 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2348 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2349 warning ("suggest parentheses around comparison in operand of |");
2352 if (code
== BIT_XOR_EXPR
)
2354 if (code1
== BIT_AND_EXPR
2355 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2356 || code2
== BIT_AND_EXPR
2357 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2358 warning ("suggest parentheses around arithmetic in operand of ^");
2359 /* Check cases like x^y==z */
2360 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2361 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2362 warning ("suggest parentheses around comparison in operand of ^");
2365 if (code
== BIT_AND_EXPR
)
2367 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
2368 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
2369 warning ("suggest parentheses around + or - in operand of &");
2370 /* Check cases like x&y==z */
2371 if (TREE_CODE_CLASS (code1
) == tcc_comparison
2372 || TREE_CODE_CLASS (code2
) == tcc_comparison
)
2373 warning ("suggest parentheses around comparison in operand of &");
2375 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
2376 if (TREE_CODE_CLASS (code
) == tcc_comparison
2377 && (TREE_CODE_CLASS (code1
) == tcc_comparison
2378 || TREE_CODE_CLASS (code2
) == tcc_comparison
))
2379 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2383 unsigned_conversion_warning (result
.value
, arg1
.value
);
2384 unsigned_conversion_warning (result
.value
, arg2
.value
);
2385 overflow_warning (result
.value
);
2390 /* Return a tree for the difference of pointers OP0 and OP1.
2391 The resulting tree has type int. */
2394 pointer_diff (tree op0
, tree op1
)
2396 tree restype
= ptrdiff_type_node
;
2398 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
2399 tree con0
, con1
, lit0
, lit1
;
2400 tree orig_op1
= op1
;
2402 if (pedantic
|| warn_pointer_arith
)
2404 if (TREE_CODE (target_type
) == VOID_TYPE
)
2405 pedwarn ("pointer of type %<void *%> used in subtraction");
2406 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
2407 pedwarn ("pointer to a function used in subtraction");
2410 /* If the conversion to ptrdiff_type does anything like widening or
2411 converting a partial to an integral mode, we get a convert_expression
2412 that is in the way to do any simplifications.
2413 (fold-const.c doesn't know that the extra bits won't be needed.
2414 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2415 different mode in place.)
2416 So first try to find a common term here 'by hand'; we want to cover
2417 at least the cases that occur in legal static initializers. */
2418 con0
= TREE_CODE (op0
) == NOP_EXPR
? TREE_OPERAND (op0
, 0) : op0
;
2419 con1
= TREE_CODE (op1
) == NOP_EXPR
? TREE_OPERAND (op1
, 0) : op1
;
2421 if (TREE_CODE (con0
) == PLUS_EXPR
)
2423 lit0
= TREE_OPERAND (con0
, 1);
2424 con0
= TREE_OPERAND (con0
, 0);
2427 lit0
= integer_zero_node
;
2429 if (TREE_CODE (con1
) == PLUS_EXPR
)
2431 lit1
= TREE_OPERAND (con1
, 1);
2432 con1
= TREE_OPERAND (con1
, 0);
2435 lit1
= integer_zero_node
;
2437 if (operand_equal_p (con0
, con1
, 0))
2444 /* First do the subtraction as integers;
2445 then drop through to build the divide operator.
2446 Do not do default conversions on the minus operator
2447 in case restype is a short type. */
2449 op0
= build_binary_op (MINUS_EXPR
, convert (restype
, op0
),
2450 convert (restype
, op1
), 0);
2451 /* This generates an error if op1 is pointer to incomplete type. */
2452 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1
))))
2453 error ("arithmetic on pointer to an incomplete type");
2455 /* This generates an error if op0 is pointer to incomplete type. */
2456 op1
= c_size_in_bytes (target_type
);
2458 /* Divide by the size, in easiest possible way. */
2459 return fold (build2 (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
)));
2462 /* Construct and perhaps optimize a tree representation
2463 for a unary operation. CODE, a tree_code, specifies the operation
2464 and XARG is the operand.
2465 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2466 the default promotions (such as from short to int).
2467 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2468 allows non-lvalues; this is only used to handle conversion of non-lvalue
2469 arrays to pointers in C99. */
2472 build_unary_op (enum tree_code code
, tree xarg
, int flag
)
2474 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2477 enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
2479 int noconvert
= flag
;
2481 if (typecode
== ERROR_MARK
)
2482 return error_mark_node
;
2483 if (typecode
== ENUMERAL_TYPE
|| typecode
== BOOLEAN_TYPE
)
2484 typecode
= INTEGER_TYPE
;
2489 /* This is used for unary plus, because a CONVERT_EXPR
2490 is enough to prevent anybody from looking inside for
2491 associativity, but won't generate any code. */
2492 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2493 || typecode
== COMPLEX_TYPE
2494 || typecode
== VECTOR_TYPE
))
2496 error ("wrong type argument to unary plus");
2497 return error_mark_node
;
2499 else if (!noconvert
)
2500 arg
= default_conversion (arg
);
2501 arg
= non_lvalue (arg
);
2505 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2506 || typecode
== COMPLEX_TYPE
2507 || typecode
== VECTOR_TYPE
))
2509 error ("wrong type argument to unary minus");
2510 return error_mark_node
;
2512 else if (!noconvert
)
2513 arg
= default_conversion (arg
);
2517 if (typecode
== INTEGER_TYPE
|| typecode
== VECTOR_TYPE
)
2520 arg
= default_conversion (arg
);
2522 else if (typecode
== COMPLEX_TYPE
)
2526 pedwarn ("ISO C does not support %<~%> for complex conjugation");
2528 arg
= default_conversion (arg
);
2532 error ("wrong type argument to bit-complement");
2533 return error_mark_node
;
2538 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
2540 error ("wrong type argument to abs");
2541 return error_mark_node
;
2543 else if (!noconvert
)
2544 arg
= default_conversion (arg
);
2548 /* Conjugating a real value is a no-op, but allow it anyway. */
2549 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2550 || typecode
== COMPLEX_TYPE
))
2552 error ("wrong type argument to conjugation");
2553 return error_mark_node
;
2555 else if (!noconvert
)
2556 arg
= default_conversion (arg
);
2559 case TRUTH_NOT_EXPR
:
2560 if (typecode
!= INTEGER_TYPE
2561 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
2562 && typecode
!= COMPLEX_TYPE
2563 /* These will convert to a pointer. */
2564 && typecode
!= ARRAY_TYPE
&& typecode
!= FUNCTION_TYPE
)
2566 error ("wrong type argument to unary exclamation mark");
2567 return error_mark_node
;
2569 arg
= lang_hooks
.truthvalue_conversion (arg
);
2570 return invert_truthvalue (arg
);
2576 if (TREE_CODE (arg
) == COMPLEX_CST
)
2577 return TREE_REALPART (arg
);
2578 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2579 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2584 if (TREE_CODE (arg
) == COMPLEX_CST
)
2585 return TREE_IMAGPART (arg
);
2586 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2587 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2589 return convert (TREE_TYPE (arg
), integer_zero_node
);
2591 case PREINCREMENT_EXPR
:
2592 case POSTINCREMENT_EXPR
:
2593 case PREDECREMENT_EXPR
:
2594 case POSTDECREMENT_EXPR
:
2596 /* Increment or decrement the real part of the value,
2597 and don't change the imaginary part. */
2598 if (typecode
== COMPLEX_TYPE
)
2603 pedwarn ("ISO C does not support %<++%> and %<--%>"
2604 " on complex types");
2606 arg
= stabilize_reference (arg
);
2607 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
2608 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
2609 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
2610 build_unary_op (code
, real
, 1), imag
);
2613 /* Report invalid types. */
2615 if (typecode
!= POINTER_TYPE
2616 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
2618 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2619 error ("wrong type argument to increment");
2621 error ("wrong type argument to decrement");
2623 return error_mark_node
;
2628 tree result_type
= TREE_TYPE (arg
);
2630 arg
= get_unwidened (arg
, 0);
2631 argtype
= TREE_TYPE (arg
);
2633 /* Compute the increment. */
2635 if (typecode
== POINTER_TYPE
)
2637 /* If pointer target is an undefined struct,
2638 we just cannot know how to do the arithmetic. */
2639 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type
)))
2641 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2642 error ("increment of pointer to unknown structure");
2644 error ("decrement of pointer to unknown structure");
2646 else if ((pedantic
|| warn_pointer_arith
)
2647 && (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
2648 || TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
))
2650 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2651 pedwarn ("wrong type argument to increment");
2653 pedwarn ("wrong type argument to decrement");
2656 inc
= c_size_in_bytes (TREE_TYPE (result_type
));
2659 inc
= integer_one_node
;
2661 inc
= convert (argtype
, inc
);
2663 /* Complain about anything else that is not a true lvalue. */
2664 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
2665 || code
== POSTINCREMENT_EXPR
)
2668 return error_mark_node
;
2670 /* Report a read-only lvalue. */
2671 if (TREE_READONLY (arg
))
2672 readonly_error (arg
,
2673 ((code
== PREINCREMENT_EXPR
2674 || code
== POSTINCREMENT_EXPR
)
2675 ? lv_increment
: lv_decrement
));
2677 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
2678 val
= boolean_increment (code
, arg
);
2680 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
2681 TREE_SIDE_EFFECTS (val
) = 1;
2682 val
= convert (result_type
, val
);
2683 if (TREE_CODE (val
) != code
)
2684 TREE_NO_WARNING (val
) = 1;
2689 /* Note that this operation never does default_conversion. */
2691 /* Let &* cancel out to simplify resulting code. */
2692 if (TREE_CODE (arg
) == INDIRECT_REF
)
2694 /* Don't let this be an lvalue. */
2695 if (lvalue_p (TREE_OPERAND (arg
, 0)))
2696 return non_lvalue (TREE_OPERAND (arg
, 0));
2697 return TREE_OPERAND (arg
, 0);
2700 /* For &x[y], return x+y */
2701 if (TREE_CODE (arg
) == ARRAY_REF
)
2703 if (!c_mark_addressable (TREE_OPERAND (arg
, 0)))
2704 return error_mark_node
;
2705 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
2706 TREE_OPERAND (arg
, 1), 1);
2709 /* Anything not already handled and not a true memory reference
2710 or a non-lvalue array is an error. */
2711 else if (typecode
!= FUNCTION_TYPE
&& !flag
2712 && !lvalue_or_else (arg
, lv_addressof
))
2713 return error_mark_node
;
2715 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
2716 argtype
= TREE_TYPE (arg
);
2718 /* If the lvalue is const or volatile, merge that into the type
2719 to which the address will point. Note that you can't get a
2720 restricted pointer by taking the address of something, so we
2721 only have to deal with `const' and `volatile' here. */
2722 if ((DECL_P (arg
) || REFERENCE_CLASS_P (arg
))
2723 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
)))
2724 argtype
= c_build_type_variant (argtype
,
2725 TREE_READONLY (arg
),
2726 TREE_THIS_VOLATILE (arg
));
2728 if (!c_mark_addressable (arg
))
2729 return error_mark_node
;
2731 gcc_assert (TREE_CODE (arg
) != COMPONENT_REF
2732 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)));
2734 argtype
= build_pointer_type (argtype
);
2736 /* ??? Cope with user tricks that amount to offsetof. Delete this
2737 when we have proper support for integer constant expressions. */
2738 val
= get_base_address (arg
);
2739 if (val
&& TREE_CODE (val
) == INDIRECT_REF
2740 && integer_zerop (TREE_OPERAND (val
, 0)))
2741 return fold_convert (argtype
, fold_offsetof (arg
));
2743 val
= build1 (ADDR_EXPR
, argtype
, arg
);
2745 if (TREE_CODE (arg
) == COMPOUND_LITERAL_EXPR
)
2746 TREE_INVARIANT (val
) = TREE_CONSTANT (val
) = 1;
2755 argtype
= TREE_TYPE (arg
);
2756 val
= build1 (code
, argtype
, arg
);
2757 return require_constant_value
? fold_initializer (val
) : fold (val
);
2760 /* Return nonzero if REF is an lvalue valid for this language.
2761 Lvalues can be assigned, unless their type has TYPE_READONLY.
2762 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
2767 enum tree_code code
= TREE_CODE (ref
);
2774 return lvalue_p (TREE_OPERAND (ref
, 0));
2776 case COMPOUND_LITERAL_EXPR
:
2786 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
2787 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
2790 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
2797 /* Give an error for storing in something that is 'const'. */
2800 readonly_error (tree arg
, enum lvalue_use use
)
2802 gcc_assert (use
== lv_assign
|| use
== lv_increment
|| use
== lv_decrement
);
2803 /* Using this macro rather than (for example) arrays of messages
2804 ensures that all the format strings are checked at compile
2806 #define READONLY_MSG(A, I, D) (use == lv_assign \
2808 : (use == lv_increment ? (I) : (D)))
2809 if (TREE_CODE (arg
) == COMPONENT_REF
)
2811 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
2812 readonly_error (TREE_OPERAND (arg
, 0), use
);
2814 error (READONLY_MSG (N_("assignment of read-only member %qs"),
2815 N_("increment of read-only member %qs"),
2816 N_("decrement of read-only member %qs")),
2817 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg
, 1))));
2819 else if (TREE_CODE (arg
) == VAR_DECL
)
2820 error (READONLY_MSG (N_("assignment of read-only variable %qs"),
2821 N_("increment of read-only variable %qs"),
2822 N_("decrement of read-only variable %qs")),
2823 IDENTIFIER_POINTER (DECL_NAME (arg
)));
2825 error (READONLY_MSG (N_("assignment of read-only location"),
2826 N_("increment of read-only location"),
2827 N_("decrement of read-only location")));
2830 /* Mark EXP saying that we need to be able to take the
2831 address of it; it should not be allocated in a register.
2832 Returns true if successful. */
2835 c_mark_addressable (tree exp
)
2840 switch (TREE_CODE (x
))
2843 if (DECL_C_BIT_FIELD (TREE_OPERAND (x
, 1)))
2846 ("cannot take address of bit-field %qD", TREE_OPERAND (x
, 1));
2850 /* ... fall through ... */
2856 x
= TREE_OPERAND (x
, 0);
2859 case COMPOUND_LITERAL_EXPR
:
2861 TREE_ADDRESSABLE (x
) = 1;
2868 if (C_DECL_REGISTER (x
)
2869 && DECL_NONLOCAL (x
))
2871 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
2874 ("global register variable %qD used in nested function", x
);
2877 pedwarn ("register variable %qD used in nested function", x
);
2879 else if (C_DECL_REGISTER (x
))
2881 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
2882 error ("address of global register variable %qD requested", x
);
2884 error ("address of register variable %qD requested", x
);
2890 TREE_ADDRESSABLE (x
) = 1;
2897 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
2900 build_conditional_expr (tree ifexp
, tree op1
, tree op2
)
2904 enum tree_code code1
;
2905 enum tree_code code2
;
2906 tree result_type
= NULL
;
2907 tree orig_op1
= op1
, orig_op2
= op2
;
2909 ifexp
= lang_hooks
.truthvalue_conversion (default_conversion (ifexp
));
2911 /* Promote both alternatives. */
2913 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
2914 op1
= default_conversion (op1
);
2915 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
2916 op2
= default_conversion (op2
);
2918 if (TREE_CODE (ifexp
) == ERROR_MARK
2919 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
2920 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
2921 return error_mark_node
;
2923 type1
= TREE_TYPE (op1
);
2924 code1
= TREE_CODE (type1
);
2925 type2
= TREE_TYPE (op2
);
2926 code2
= TREE_CODE (type2
);
2928 /* C90 does not permit non-lvalue arrays in conditional expressions.
2929 In C99 they will be pointers by now. */
2930 if (code1
== ARRAY_TYPE
|| code2
== ARRAY_TYPE
)
2932 error ("non-lvalue array in conditional expression");
2933 return error_mark_node
;
2936 /* Quickly detect the usual case where op1 and op2 have the same type
2938 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
2941 result_type
= type1
;
2943 result_type
= TYPE_MAIN_VARIANT (type1
);
2945 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
2946 || code1
== COMPLEX_TYPE
)
2947 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
2948 || code2
== COMPLEX_TYPE
))
2950 result_type
= c_common_type (type1
, type2
);
2952 /* If -Wsign-compare, warn here if type1 and type2 have
2953 different signedness. We'll promote the signed to unsigned
2954 and later code won't know it used to be different.
2955 Do this check on the original types, so that explicit casts
2956 will be considered, but default promotions won't. */
2957 if (warn_sign_compare
&& !skip_evaluation
)
2959 int unsigned_op1
= TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
2960 int unsigned_op2
= TYPE_UNSIGNED (TREE_TYPE (orig_op2
));
2962 if (unsigned_op1
^ unsigned_op2
)
2964 /* Do not warn if the result type is signed, since the
2965 signed type will only be chosen if it can represent
2966 all the values of the unsigned type. */
2967 if (!TYPE_UNSIGNED (result_type
))
2969 /* Do not warn if the signed quantity is an unsuffixed
2970 integer literal (or some static constant expression
2971 involving such literals) and it is non-negative. */
2972 else if ((unsigned_op2
&& tree_expr_nonnegative_p (op1
))
2973 || (unsigned_op1
&& tree_expr_nonnegative_p (op2
)))
2976 warning ("signed and unsigned type in conditional expression");
2980 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
2982 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
2983 pedwarn ("ISO C forbids conditional expr with only one void side");
2984 result_type
= void_type_node
;
2986 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
2988 if (comp_target_types (type1
, type2
, 1))
2989 result_type
= common_pointer_type (type1
, type2
);
2990 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
2991 && TREE_CODE (orig_op1
) != NOP_EXPR
)
2992 result_type
= qualify_type (type2
, type1
);
2993 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
2994 && TREE_CODE (orig_op2
) != NOP_EXPR
)
2995 result_type
= qualify_type (type1
, type2
);
2996 else if (VOID_TYPE_P (TREE_TYPE (type1
)))
2998 if (pedantic
&& TREE_CODE (TREE_TYPE (type2
)) == 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 (type1
),
3002 TREE_TYPE (type2
)));
3004 else if (VOID_TYPE_P (TREE_TYPE (type2
)))
3006 if (pedantic
&& TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
3007 pedwarn ("ISO C forbids conditional expr between "
3008 "%<void *%> and function pointer");
3009 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
3010 TREE_TYPE (type1
)));
3014 pedwarn ("pointer type mismatch in conditional expression");
3015 result_type
= build_pointer_type (void_type_node
);
3018 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
3020 if (!integer_zerop (op2
))
3021 pedwarn ("pointer/integer type mismatch in conditional expression");
3024 op2
= null_pointer_node
;
3026 result_type
= type1
;
3028 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3030 if (!integer_zerop (op1
))
3031 pedwarn ("pointer/integer type mismatch in conditional expression");
3034 op1
= null_pointer_node
;
3036 result_type
= type2
;
3041 if (flag_cond_mismatch
)
3042 result_type
= void_type_node
;
3045 error ("type mismatch in conditional expression");
3046 return error_mark_node
;
3050 /* Merge const and volatile flags of the incoming types. */
3052 = build_type_variant (result_type
,
3053 TREE_READONLY (op1
) || TREE_READONLY (op2
),
3054 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
3056 if (result_type
!= TREE_TYPE (op1
))
3057 op1
= convert_and_check (result_type
, op1
);
3058 if (result_type
!= TREE_TYPE (op2
))
3059 op2
= convert_and_check (result_type
, op2
);
3061 if (TREE_CODE (ifexp
) == INTEGER_CST
)
3062 return non_lvalue (integer_zerop (ifexp
) ? op2
: op1
);
3064 return fold (build3 (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
3067 /* Return a compound expression that performs two expressions and
3068 returns the value of the second of them. */
3071 build_compound_expr (tree expr1
, tree expr2
)
3073 /* Convert arrays and functions to pointers. */
3074 expr2
= default_function_array_conversion (expr2
);
3076 if (!TREE_SIDE_EFFECTS (expr1
))
3078 /* The left-hand operand of a comma expression is like an expression
3079 statement: with -Wextra or -Wunused, we should warn if it doesn't have
3080 any side-effects, unless it was explicitly cast to (void). */
3081 if (warn_unused_value
3082 && !(TREE_CODE (expr1
) == CONVERT_EXPR
3083 && VOID_TYPE_P (TREE_TYPE (expr1
))))
3084 warning ("left-hand operand of comma expression has no effect");
3087 /* With -Wunused, we should also warn if the left-hand operand does have
3088 side-effects, but computes a value which is not used. For example, in
3089 `foo() + bar(), baz()' the result of the `+' operator is not used,
3090 so we should issue a warning. */
3091 else if (warn_unused_value
)
3092 warn_if_unused_value (expr1
, input_location
);
3094 return build2 (COMPOUND_EXPR
, TREE_TYPE (expr2
), expr1
, expr2
);
3097 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3100 build_c_cast (tree type
, tree expr
)
3104 if (type
== error_mark_node
|| expr
== error_mark_node
)
3105 return error_mark_node
;
3107 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3108 only in <protocol> qualifications. But when constructing cast expressions,
3109 the protocols do matter and must be kept around. */
3110 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
3111 return build1 (NOP_EXPR
, type
, expr
);
3113 type
= TYPE_MAIN_VARIANT (type
);
3115 if (TREE_CODE (type
) == ARRAY_TYPE
)
3117 error ("cast specifies array type");
3118 return error_mark_node
;
3121 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3123 error ("cast specifies function type");
3124 return error_mark_node
;
3127 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
3131 if (TREE_CODE (type
) == RECORD_TYPE
3132 || TREE_CODE (type
) == UNION_TYPE
)
3133 pedwarn ("ISO C forbids casting nonscalar to the same type");
3136 else if (TREE_CODE (type
) == UNION_TYPE
)
3139 value
= default_function_array_conversion (value
);
3141 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3142 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
3143 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
3151 pedwarn ("ISO C forbids casts to union type");
3152 t
= digest_init (type
,
3153 build_constructor (type
,
3154 build_tree_list (field
, value
)),
3156 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
3157 TREE_INVARIANT (t
) = TREE_INVARIANT (value
);
3160 error ("cast to union type from type not present in union");
3161 return error_mark_node
;
3167 /* If casting to void, avoid the error that would come
3168 from default_conversion in the case of a non-lvalue array. */
3169 if (type
== void_type_node
)
3170 return build1 (CONVERT_EXPR
, type
, value
);
3172 /* Convert functions and arrays to pointers,
3173 but don't convert any other types. */
3174 value
= default_function_array_conversion (value
);
3175 otype
= TREE_TYPE (value
);
3177 /* Optionally warn about potentially worrisome casts. */
3180 && TREE_CODE (type
) == POINTER_TYPE
3181 && TREE_CODE (otype
) == POINTER_TYPE
)
3183 tree in_type
= type
;
3184 tree in_otype
= otype
;
3188 /* Check that the qualifiers on IN_TYPE are a superset of
3189 the qualifiers of IN_OTYPE. The outermost level of
3190 POINTER_TYPE nodes is uninteresting and we stop as soon
3191 as we hit a non-POINTER_TYPE node on either type. */
3194 in_otype
= TREE_TYPE (in_otype
);
3195 in_type
= TREE_TYPE (in_type
);
3197 /* GNU C allows cv-qualified function types. 'const'
3198 means the function is very pure, 'volatile' means it
3199 can't return. We need to warn when such qualifiers
3200 are added, not when they're taken away. */
3201 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
3202 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
3203 added
|= (TYPE_QUALS (in_type
) & ~TYPE_QUALS (in_otype
));
3205 discarded
|= (TYPE_QUALS (in_otype
) & ~TYPE_QUALS (in_type
));
3207 while (TREE_CODE (in_type
) == POINTER_TYPE
3208 && TREE_CODE (in_otype
) == POINTER_TYPE
);
3211 warning ("cast adds new qualifiers to function type");
3214 /* There are qualifiers present in IN_OTYPE that are not
3215 present in IN_TYPE. */
3216 warning ("cast discards qualifiers from pointer target type");
3219 /* Warn about possible alignment problems. */
3220 if (STRICT_ALIGNMENT
&& warn_cast_align
3221 && TREE_CODE (type
) == POINTER_TYPE
3222 && TREE_CODE (otype
) == POINTER_TYPE
3223 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
3224 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3225 /* Don't warn about opaque types, where the actual alignment
3226 restriction is unknown. */
3227 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
3228 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
3229 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
3230 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
3231 warning ("cast increases required alignment of target type");
3233 if (TREE_CODE (type
) == INTEGER_TYPE
3234 && TREE_CODE (otype
) == POINTER_TYPE
3235 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3236 && !TREE_CONSTANT (value
))
3237 warning ("cast from pointer to integer of different size");
3239 if (warn_bad_function_cast
3240 && TREE_CODE (value
) == CALL_EXPR
3241 && TREE_CODE (type
) != TREE_CODE (otype
))
3242 warning ("cast from function call of type %qT to non-matching "
3243 "type %qT", otype
, type
);
3245 if (TREE_CODE (type
) == POINTER_TYPE
3246 && TREE_CODE (otype
) == INTEGER_TYPE
3247 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3248 /* Don't warn about converting any constant. */
3249 && !TREE_CONSTANT (value
))
3250 warning ("cast to pointer from integer of different size");
3252 if (TREE_CODE (type
) == POINTER_TYPE
3253 && TREE_CODE (otype
) == POINTER_TYPE
3254 && TREE_CODE (expr
) == ADDR_EXPR
3255 && DECL_P (TREE_OPERAND (expr
, 0))
3256 && flag_strict_aliasing
&& warn_strict_aliasing
3257 && !VOID_TYPE_P (TREE_TYPE (type
)))
3259 /* Casting the address of a decl to non void pointer. Warn
3260 if the cast breaks type based aliasing. */
3261 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)))
3262 warning ("type-punning to incomplete type might break strict-aliasing rules");
3265 HOST_WIDE_INT set1
= get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
3266 HOST_WIDE_INT set2
= get_alias_set (TREE_TYPE (type
));
3268 if (!alias_sets_conflict_p (set1
, set2
))
3269 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3270 else if (warn_strict_aliasing
> 1
3271 && !alias_sets_might_conflict_p (set1
, set2
))
3272 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3276 /* If pedantic, warn for conversions between function and object
3277 pointer types, except for converting a null pointer constant
3278 to function pointer type. */
3280 && TREE_CODE (type
) == POINTER_TYPE
3281 && TREE_CODE (otype
) == POINTER_TYPE
3282 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
3283 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
3284 pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3287 && TREE_CODE (type
) == POINTER_TYPE
3288 && TREE_CODE (otype
) == POINTER_TYPE
3289 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
3290 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3291 && !(integer_zerop (value
) && TREE_TYPE (otype
) == void_type_node
3292 && TREE_CODE (expr
) != NOP_EXPR
))
3293 pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3296 value
= convert (type
, value
);
3298 /* Ignore any integer overflow caused by the cast. */
3299 if (TREE_CODE (value
) == INTEGER_CST
)
3301 if (EXPR_P (ovalue
))
3302 /* If OVALUE had overflow set, then so will VALUE, so it
3303 is safe to overwrite. */
3304 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
3306 TREE_OVERFLOW (value
) = 0;
3308 if (CONSTANT_CLASS_P (ovalue
))
3309 /* Similarly, constant_overflow cannot have become
3311 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
3315 /* Don't let a cast be an lvalue. */
3317 value
= non_lvalue (value
);
3322 /* Interpret a cast of expression EXPR to type TYPE. */
3324 c_cast_expr (struct c_type_name
*type_name
, tree expr
)
3327 int saved_wsp
= warn_strict_prototypes
;
3329 /* This avoids warnings about unprototyped casts on
3330 integers. E.g. "#define SIG_DFL (void(*)())0". */
3331 if (TREE_CODE (expr
) == INTEGER_CST
)
3332 warn_strict_prototypes
= 0;
3333 type
= groktypename (type_name
);
3334 warn_strict_prototypes
= saved_wsp
;
3336 return build_c_cast (type
, expr
);
3340 /* Build an assignment expression of lvalue LHS from value RHS.
3341 MODIFYCODE is the code for a binary operator that we use
3342 to combine the old value of LHS with RHS to get the new value.
3343 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3346 build_modify_expr (tree lhs
, enum tree_code modifycode
, tree rhs
)
3350 tree lhstype
= TREE_TYPE (lhs
);
3351 tree olhstype
= lhstype
;
3353 /* Types that aren't fully specified cannot be used in assignments. */
3354 lhs
= require_complete_type (lhs
);
3356 /* Avoid duplicate error messages from operands that had errors. */
3357 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
3358 return error_mark_node
;
3360 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3361 /* Do not use STRIP_NOPS here. We do not want an enumerator
3362 whose value is 0 to count as a null pointer constant. */
3363 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3364 rhs
= TREE_OPERAND (rhs
, 0);
3368 /* If a binary op has been requested, combine the old LHS value with the RHS
3369 producing the value we should actually store into the LHS. */
3371 if (modifycode
!= NOP_EXPR
)
3373 lhs
= stabilize_reference (lhs
);
3374 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
3377 if (!lvalue_or_else (lhs
, lv_assign
))
3378 return error_mark_node
;
3380 /* Give an error for storing in something that is 'const'. */
3382 if (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
3383 || ((TREE_CODE (lhstype
) == RECORD_TYPE
3384 || TREE_CODE (lhstype
) == UNION_TYPE
)
3385 && C_TYPE_FIELDS_READONLY (lhstype
)))
3386 readonly_error (lhs
, lv_assign
);
3388 /* If storing into a structure or union member,
3389 it has probably been given type `int'.
3390 Compute the type that would go with
3391 the actual amount of storage the member occupies. */
3393 if (TREE_CODE (lhs
) == COMPONENT_REF
3394 && (TREE_CODE (lhstype
) == INTEGER_TYPE
3395 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
3396 || TREE_CODE (lhstype
) == REAL_TYPE
3397 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
3398 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
3400 /* If storing in a field that is in actuality a short or narrower than one,
3401 we must store in the field in its actual type. */
3403 if (lhstype
!= TREE_TYPE (lhs
))
3405 lhs
= copy_node (lhs
);
3406 TREE_TYPE (lhs
) = lhstype
;
3409 /* Convert new value to destination type. */
3411 newrhs
= convert_for_assignment (lhstype
, newrhs
, ic_assign
,
3412 NULL_TREE
, NULL_TREE
, 0);
3413 if (TREE_CODE (newrhs
) == ERROR_MARK
)
3414 return error_mark_node
;
3416 /* Scan operands. */
3418 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
3419 TREE_SIDE_EFFECTS (result
) = 1;
3421 /* If we got the LHS in a different type for storing in,
3422 convert the result back to the nominal type of LHS
3423 so that the value we return always has the same type
3424 as the LHS argument. */
3426 if (olhstype
== TREE_TYPE (result
))
3428 return convert_for_assignment (olhstype
, result
, ic_assign
,
3429 NULL_TREE
, NULL_TREE
, 0);
3432 /* Convert value RHS to type TYPE as preparation for an assignment
3433 to an lvalue of type TYPE.
3434 The real work of conversion is done by `convert'.
3435 The purpose of this function is to generate error messages
3436 for assignments that are not allowed in C.
3437 ERRTYPE says whether it is argument passing, assignment,
3438 initialization or return.
3440 FUNCTION is a tree for the function being called.
3441 PARMNUM is the number of the argument, for printing in error messages. */
3444 convert_for_assignment (tree type
, tree rhs
, enum impl_conv errtype
,
3445 tree fundecl
, tree function
, int parmnum
)
3447 enum tree_code codel
= TREE_CODE (type
);
3449 enum tree_code coder
;
3450 tree rname
= NULL_TREE
;
3452 if (errtype
== ic_argpass
|| errtype
== ic_argpass_nonproto
)
3455 /* Change pointer to function to the function itself for
3457 if (TREE_CODE (function
) == ADDR_EXPR
3458 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
3459 function
= TREE_OPERAND (function
, 0);
3461 /* Handle an ObjC selector specially for diagnostics. */
3462 selector
= objc_message_selector ();
3464 if (selector
&& parmnum
> 2)
3471 /* This macro is used to emit diagnostics to ensure that all format
3472 strings are complete sentences, visible to gettext and checked at
3474 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \
3479 pedwarn (AR, parmnum, rname); \
3481 case ic_argpass_nonproto: \
3482 warning (AR, parmnum, rname); \
3494 gcc_unreachable (); \
3498 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3499 /* Do not use STRIP_NOPS here. We do not want an enumerator
3500 whose value is 0 to count as a null pointer constant. */
3501 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3502 rhs
= TREE_OPERAND (rhs
, 0);
3504 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
3505 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
)
3506 rhs
= default_conversion (rhs
);
3507 else if (optimize
&& TREE_CODE (rhs
) == VAR_DECL
)
3508 rhs
= decl_constant_value_for_broken_optimization (rhs
);
3510 rhstype
= TREE_TYPE (rhs
);
3511 coder
= TREE_CODE (rhstype
);
3513 if (coder
== ERROR_MARK
)
3514 return error_mark_node
;
3516 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
3518 overflow_warning (rhs
);
3519 /* Check for Objective-C protocols. This will automatically
3520 issue a warning if there are protocol violations. No need to
3521 use the return value. */
3522 if (c_dialect_objc ())
3523 objc_comptypes (type
, rhstype
, 0);
3527 if (coder
== VOID_TYPE
)
3529 /* Except for passing an argument to an unprototyped function,
3530 this is a constraint violation. When passing an argument to
3531 an unprototyped function, it is compile-time undefined;
3532 making it a constraint in that case was rejected in
3534 error ("void value not ignored as it ought to be");
3535 return error_mark_node
;
3537 /* A type converts to a reference to it.
3538 This code doesn't fully support references, it's just for the
3539 special case of va_start and va_copy. */
3540 if (codel
== REFERENCE_TYPE
3541 && comptypes (TREE_TYPE (type
), TREE_TYPE (rhs
)) == 1)
3543 if (!lvalue_p (rhs
))
3545 error ("cannot pass rvalue to reference parameter");
3546 return error_mark_node
;
3548 if (!c_mark_addressable (rhs
))
3549 return error_mark_node
;
3550 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
3552 /* We already know that these two types are compatible, but they
3553 may not be exactly identical. In fact, `TREE_TYPE (type)' is
3554 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3555 likely to be va_list, a typedef to __builtin_va_list, which
3556 is different enough that it will cause problems later. */
3557 if (TREE_TYPE (TREE_TYPE (rhs
)) != TREE_TYPE (type
))
3558 rhs
= build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), rhs
);
3560 rhs
= build1 (NOP_EXPR
, type
, rhs
);
3563 /* Some types can interconvert without explicit casts. */
3564 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
3565 && vector_types_convertible_p (type
, TREE_TYPE (rhs
)))
3566 return convert (type
, rhs
);
3567 /* Arithmetic types all interconvert, and enum is treated like int. */
3568 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
3569 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
3570 || codel
== BOOLEAN_TYPE
)
3571 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
3572 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
3573 || coder
== BOOLEAN_TYPE
))
3574 return convert_and_check (type
, rhs
);
3576 /* Conversion to a transparent union from its member types.
3577 This applies only to function arguments. */
3578 else if (codel
== UNION_TYPE
&& TYPE_TRANSPARENT_UNION (type
)
3579 && (errtype
== ic_argpass
|| errtype
== ic_argpass_nonproto
))
3582 tree marginal_memb_type
= 0;
3584 for (memb_types
= TYPE_FIELDS (type
); memb_types
;
3585 memb_types
= TREE_CHAIN (memb_types
))
3587 tree memb_type
= TREE_TYPE (memb_types
);
3589 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
3590 TYPE_MAIN_VARIANT (rhstype
)))
3593 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
3596 if (coder
== POINTER_TYPE
)
3598 tree ttl
= TREE_TYPE (memb_type
);
3599 tree ttr
= TREE_TYPE (rhstype
);
3601 /* Any non-function converts to a [const][volatile] void *
3602 and vice versa; otherwise, targets must be the same.
3603 Meanwhile, the lhs target must have all the qualifiers of
3605 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3606 || comp_target_types (memb_type
, rhstype
, 0))
3608 /* If this type won't generate any warnings, use it. */
3609 if (TYPE_QUALS (ttl
) == TYPE_QUALS (ttr
)
3610 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
3611 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
3612 ? ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
3613 == TYPE_QUALS (ttr
))
3614 : ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
3615 == TYPE_QUALS (ttl
))))
3618 /* Keep looking for a better type, but remember this one. */
3619 if (!marginal_memb_type
)
3620 marginal_memb_type
= memb_type
;
3624 /* Can convert integer zero to any pointer type. */
3625 if (integer_zerop (rhs
)
3626 || (TREE_CODE (rhs
) == NOP_EXPR
3627 && integer_zerop (TREE_OPERAND (rhs
, 0))))
3629 rhs
= null_pointer_node
;
3634 if (memb_types
|| marginal_memb_type
)
3638 /* We have only a marginally acceptable member type;
3639 it needs a warning. */
3640 tree ttl
= TREE_TYPE (marginal_memb_type
);
3641 tree ttr
= TREE_TYPE (rhstype
);
3643 /* Const and volatile mean something different for function
3644 types, so the usual warnings are not appropriate. */
3645 if (TREE_CODE (ttr
) == FUNCTION_TYPE
3646 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
3648 /* Because const and volatile on functions are
3649 restrictions that say the function will not do
3650 certain things, it is okay to use a const or volatile
3651 function where an ordinary one is wanted, but not
3653 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
3654 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE "
3655 "makes qualified function "
3656 "pointer from unqualified"),
3657 N_("assignment makes qualified "
3658 "function pointer from "
3660 N_("initialization makes qualified "
3661 "function pointer from "
3663 N_("return makes qualified function "
3664 "pointer from unqualified"));
3666 else if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
3667 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3668 "qualifiers from pointer target type"),
3669 N_("assignment discards qualifiers "
3670 "from pointer target type"),
3671 N_("initialization discards qualifiers "
3672 "from pointer target type"),
3673 N_("return discards qualifiers from "
3674 "pointer target type"));
3677 if (pedantic
&& !DECL_IN_SYSTEM_HEADER (fundecl
))
3678 pedwarn ("ISO C prohibits argument conversion to union type");
3680 return build1 (NOP_EXPR
, type
, rhs
);
3684 /* Conversions among pointers */
3685 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
3686 && (coder
== codel
))
3688 tree ttl
= TREE_TYPE (type
);
3689 tree ttr
= TREE_TYPE (rhstype
);
3692 bool is_opaque_pointer
;
3693 int target_cmp
= 0; /* Cache comp_target_types () result. */
3695 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
3696 mvl
= TYPE_MAIN_VARIANT (mvl
);
3697 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
3698 mvr
= TYPE_MAIN_VARIANT (mvr
);
3699 /* Opaque pointers are treated like void pointers. */
3700 is_opaque_pointer
= (targetm
.vector_opaque_p (type
)
3701 || targetm
.vector_opaque_p (rhstype
))
3702 && TREE_CODE (ttl
) == VECTOR_TYPE
3703 && TREE_CODE (ttr
) == VECTOR_TYPE
;
3705 /* Any non-function converts to a [const][volatile] void *
3706 and vice versa; otherwise, targets must be the same.
3707 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
3708 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3709 || (target_cmp
= comp_target_types (type
, rhstype
, 0))
3710 || is_opaque_pointer
3711 || (c_common_unsigned_type (mvl
)
3712 == c_common_unsigned_type (mvr
)))
3715 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
3718 /* Check TREE_CODE to catch cases like (void *) (char *) 0
3719 which are not ANSI null ptr constants. */
3720 && (!integer_zerop (rhs
) || TREE_CODE (rhs
) == NOP_EXPR
)
3721 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
3722 WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of "
3723 "%qE between function pointer "
3725 N_("ISO C forbids assignment between "
3726 "function pointer and %<void *%>"),
3727 N_("ISO C forbids initialization between "
3728 "function pointer and %<void *%>"),
3729 N_("ISO C forbids return between function "
3730 "pointer and %<void *%>"));
3731 /* Const and volatile mean something different for function types,
3732 so the usual warnings are not appropriate. */
3733 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
3734 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
3736 if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
3737 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3738 "qualifiers from pointer target type"),
3739 N_("assignment discards qualifiers "
3740 "from pointer target type"),
3741 N_("initialization discards qualifiers "
3742 "from pointer target type"),
3743 N_("return discards qualifiers from "
3744 "pointer target type"));
3745 /* If this is not a case of ignoring a mismatch in signedness,
3747 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
3750 /* If there is a mismatch, do warn. */
3751 else if (warn_pointer_sign
)
3752 WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument "
3753 "%d of %qE differ in signedness"),
3754 N_("pointer targets in assignment "
3755 "differ in signedness"),
3756 N_("pointer targets in initialization "
3757 "differ in signedness"),
3758 N_("pointer targets in return differ "
3761 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
3762 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
3764 /* Because const and volatile on functions are restrictions
3765 that say the function will not do certain things,
3766 it is okay to use a const or volatile function
3767 where an ordinary one is wanted, but not vice-versa. */
3768 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
3769 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3770 "qualified function pointer "
3771 "from unqualified"),
3772 N_("assignment makes qualified function "
3773 "pointer from unqualified"),
3774 N_("initialization makes qualified "
3775 "function pointer from unqualified"),
3776 N_("return makes qualified function "
3777 "pointer from unqualified"));
3781 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from "
3782 "incompatible pointer type"),
3783 N_("assignment from incompatible pointer type"),
3784 N_("initialization from incompatible "
3786 N_("return from incompatible pointer type"));
3787 return convert (type
, rhs
);
3789 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
3791 /* ??? This should not be an error when inlining calls to
3792 unprototyped functions. */
3793 error ("invalid use of non-lvalue array");
3794 return error_mark_node
;
3796 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
3798 /* An explicit constant 0 can convert to a pointer,
3799 or one that results from arithmetic, even including
3800 a cast to integer type. */
3801 if (!(TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
))
3803 !(TREE_CODE (rhs
) == NOP_EXPR
3804 && TREE_CODE (TREE_TYPE (rhs
)) == INTEGER_TYPE
3805 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == INTEGER_CST
3806 && integer_zerop (TREE_OPERAND (rhs
, 0))))
3807 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3808 "pointer from integer without a cast"),
3809 N_("assignment makes pointer from integer "
3811 N_("initialization makes pointer from "
3812 "integer without a cast"),
3813 N_("return makes pointer from integer "
3816 return convert (type
, rhs
);
3818 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
3820 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer "
3821 "from pointer without a cast"),
3822 N_("assignment makes integer from pointer "
3824 N_("initialization makes integer from pointer "
3826 N_("return makes integer from pointer "
3828 return convert (type
, rhs
);
3830 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
3831 return convert (type
, rhs
);
3836 case ic_argpass_nonproto
:
3837 /* ??? This should not be an error when inlining calls to
3838 unprototyped functions. */
3839 error ("incompatible type for argument %d of %qE", parmnum
, rname
);
3842 error ("incompatible types in assignment");
3845 error ("incompatible types in initialization");
3848 error ("incompatible types in return");
3854 return error_mark_node
;
3857 /* Convert VALUE for assignment into inlined parameter PARM. ARGNUM
3858 is used for error and waring reporting and indicates which argument
3859 is being processed. */
3862 c_convert_parm_for_inlining (tree parm
, tree value
, tree fn
, int argnum
)
3866 /* If FN was prototyped, the value has been converted already
3867 in convert_arguments. */
3868 if (!value
|| TYPE_ARG_TYPES (TREE_TYPE (fn
)))
3871 type
= TREE_TYPE (parm
);
3872 ret
= convert_for_assignment (type
, value
,
3873 ic_argpass_nonproto
, fn
,
3875 if (targetm
.calls
.promote_prototypes (TREE_TYPE (fn
))
3876 && INTEGRAL_TYPE_P (type
)
3877 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
3878 ret
= default_conversion (ret
);
3882 /* If VALUE is a compound expr all of whose expressions are constant, then
3883 return its value. Otherwise, return error_mark_node.
3885 This is for handling COMPOUND_EXPRs as initializer elements
3886 which is allowed with a warning when -pedantic is specified. */
3889 valid_compound_expr_initializer (tree value
, tree endtype
)
3891 if (TREE_CODE (value
) == COMPOUND_EXPR
)
3893 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
3895 return error_mark_node
;
3896 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
3899 else if (!initializer_constant_valid_p (value
, endtype
))
3900 return error_mark_node
;
3905 /* Perform appropriate conversions on the initial value of a variable,
3906 store it in the declaration DECL,
3907 and print any error messages that are appropriate.
3908 If the init is invalid, store an ERROR_MARK. */
3911 store_init_value (tree decl
, tree init
)
3915 /* If variable's type was invalidly declared, just ignore it. */
3917 type
= TREE_TYPE (decl
);
3918 if (TREE_CODE (type
) == ERROR_MARK
)
3921 /* Digest the specified initializer into an expression. */
3923 value
= digest_init (type
, init
, true, TREE_STATIC (decl
));
3925 /* Store the expression if valid; else report error. */
3927 if (warn_traditional
&& !in_system_header
3928 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
3929 warning ("traditional C rejects automatic aggregate initialization");
3931 DECL_INITIAL (decl
) = value
;
3933 /* ANSI wants warnings about out-of-range constant initializers. */
3934 STRIP_TYPE_NOPS (value
);
3935 constant_expression_warning (value
);
3937 /* Check if we need to set array size from compound literal size. */
3938 if (TREE_CODE (type
) == ARRAY_TYPE
3939 && TYPE_DOMAIN (type
) == 0
3940 && value
!= error_mark_node
)
3942 tree inside_init
= init
;
3944 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
3945 inside_init
= TREE_OPERAND (init
, 0);
3946 inside_init
= fold (inside_init
);
3948 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
3950 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
3952 if (TYPE_DOMAIN (TREE_TYPE (decl
)))
3954 /* For int foo[] = (int [3]){1}; we need to set array size
3955 now since later on array initializer will be just the
3956 brace enclosed list of the compound literal. */
3957 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (decl
));
3959 layout_decl (decl
, 0);
3965 /* Methods for storing and printing names for error messages. */
3967 /* Implement a spelling stack that allows components of a name to be pushed
3968 and popped. Each element on the stack is this structure. */
3980 #define SPELLING_STRING 1
3981 #define SPELLING_MEMBER 2
3982 #define SPELLING_BOUNDS 3
3984 static struct spelling
*spelling
; /* Next stack element (unused). */
3985 static struct spelling
*spelling_base
; /* Spelling stack base. */
3986 static int spelling_size
; /* Size of the spelling stack. */
3988 /* Macros to save and restore the spelling stack around push_... functions.
3989 Alternative to SAVE_SPELLING_STACK. */
3991 #define SPELLING_DEPTH() (spelling - spelling_base)
3992 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3994 /* Push an element on the spelling stack with type KIND and assign VALUE
3997 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
3999 int depth = SPELLING_DEPTH (); \
4001 if (depth >= spelling_size) \
4003 spelling_size += 10; \
4004 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
4006 RESTORE_SPELLING_DEPTH (depth); \
4009 spelling->kind = (KIND); \
4010 spelling->MEMBER = (VALUE); \
4014 /* Push STRING on the stack. Printed literally. */
4017 push_string (const char *string
)
4019 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
4022 /* Push a member name on the stack. Printed as '.' STRING. */
4025 push_member_name (tree decl
)
4027 const char *const string
4028 = DECL_NAME (decl
) ? IDENTIFIER_POINTER (DECL_NAME (decl
)) : "<anonymous>";
4029 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
4032 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4035 push_array_bounds (int bounds
)
4037 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
4040 /* Compute the maximum size in bytes of the printed spelling. */
4043 spelling_length (void)
4048 for (p
= spelling_base
; p
< spelling
; p
++)
4050 if (p
->kind
== SPELLING_BOUNDS
)
4053 size
+= strlen (p
->u
.s
) + 1;
4059 /* Print the spelling to BUFFER and return it. */
4062 print_spelling (char *buffer
)
4067 for (p
= spelling_base
; p
< spelling
; p
++)
4068 if (p
->kind
== SPELLING_BOUNDS
)
4070 sprintf (d
, "[%d]", p
->u
.i
);
4076 if (p
->kind
== SPELLING_MEMBER
)
4078 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
4085 /* Issue an error message for a bad initializer component.
4086 MSGID identifies the message.
4087 The component name is taken from the spelling stack. */
4090 error_init (const char *msgid
)
4094 error ("%s", _(msgid
));
4095 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4097 error ("(near initialization for %qs)", ofwhat
);
4100 /* Issue a pedantic warning for a bad initializer component.
4101 MSGID identifies the message.
4102 The component name is taken from the spelling stack. */
4105 pedwarn_init (const char *msgid
)
4109 pedwarn ("%s", _(msgid
));
4110 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4112 pedwarn ("(near initialization for %qs)", ofwhat
);
4115 /* Issue a warning for a bad initializer component.
4116 MSGID identifies the message.
4117 The component name is taken from the spelling stack. */
4120 warning_init (const char *msgid
)
4124 warning ("%s", _(msgid
));
4125 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4127 warning ("(near initialization for %qs)", ofwhat
);
4130 /* If TYPE is an array type and EXPR is a parenthesized string
4131 constant, warn if pedantic that EXPR is being used to initialize an
4132 object of type TYPE. */
4135 maybe_warn_string_init (tree type
, struct c_expr expr
)
4138 && TREE_CODE (type
) == ARRAY_TYPE
4139 && TREE_CODE (expr
.value
) == STRING_CST
4140 && expr
.original_code
!= STRING_CST
)
4141 pedwarn_init ("array initialized from parenthesized string constant");
4144 /* Digest the parser output INIT as an initializer for type TYPE.
4145 Return a C expression of type TYPE to represent the initial value.
4147 If INIT is a string constant, STRICT_STRING is true if it is
4148 unparenthesized or we should not warn here for it being parenthesized.
4149 For other types of INIT, STRICT_STRING is not used.
4151 REQUIRE_CONSTANT requests an error if non-constant initializers or
4152 elements are seen. */
4155 digest_init (tree type
, tree init
, bool strict_string
, int require_constant
)
4157 enum tree_code code
= TREE_CODE (type
);
4158 tree inside_init
= init
;
4160 if (type
== error_mark_node
4161 || init
== error_mark_node
4162 || TREE_TYPE (init
) == error_mark_node
)
4163 return error_mark_node
;
4165 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4166 /* Do not use STRIP_NOPS here. We do not want an enumerator
4167 whose value is 0 to count as a null pointer constant. */
4168 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
4169 inside_init
= TREE_OPERAND (init
, 0);
4171 inside_init
= fold (inside_init
);
4173 /* Initialization of an array of chars from a string constant
4174 optionally enclosed in braces. */
4176 if (code
== ARRAY_TYPE
&& inside_init
4177 && TREE_CODE (inside_init
) == STRING_CST
)
4179 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4180 /* Note that an array could be both an array of character type
4181 and an array of wchar_t if wchar_t is signed char or unsigned
4183 bool char_array
= (typ1
== char_type_node
4184 || typ1
== signed_char_type_node
4185 || typ1
== unsigned_char_type_node
);
4186 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
4187 if (char_array
|| wchar_array
)
4191 expr
.value
= inside_init
;
4192 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
4193 maybe_warn_string_init (type
, expr
);
4196 = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)))
4199 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4200 TYPE_MAIN_VARIANT (type
)))
4203 if (!wchar_array
&& !char_string
)
4205 error_init ("char-array initialized from wide string");
4206 return error_mark_node
;
4208 if (char_string
&& !char_array
)
4210 error_init ("wchar_t-array initialized from non-wide string");
4211 return error_mark_node
;
4214 TREE_TYPE (inside_init
) = type
;
4215 if (TYPE_DOMAIN (type
) != 0
4216 && TYPE_SIZE (type
) != 0
4217 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
4218 /* Subtract 1 (or sizeof (wchar_t))
4219 because it's ok to ignore the terminating null char
4220 that is counted in the length of the constant. */
4221 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
4222 TREE_STRING_LENGTH (inside_init
)
4223 - ((TYPE_PRECISION (typ1
)
4224 != TYPE_PRECISION (char_type_node
))
4225 ? (TYPE_PRECISION (wchar_type_node
)
4228 pedwarn_init ("initializer-string for array of chars is too long");
4232 else if (INTEGRAL_TYPE_P (typ1
))
4234 error_init ("array of inappropriate type initialized "
4235 "from string constant");
4236 return error_mark_node
;
4240 /* Build a VECTOR_CST from a *constant* vector constructor. If the
4241 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4242 below and handle as a constructor. */
4243 if (code
== VECTOR_TYPE
4244 && TREE_CODE (TREE_TYPE (inside_init
)) == VECTOR_TYPE
4245 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
)
4246 && TREE_CONSTANT (inside_init
))
4248 if (TREE_CODE (inside_init
) == VECTOR_CST
4249 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4250 TYPE_MAIN_VARIANT (type
)))
4253 if (TREE_CODE (inside_init
) == CONSTRUCTOR
)
4257 /* Iterate through elements and check if all constructor
4258 elements are *_CSTs. */
4259 for (link
= CONSTRUCTOR_ELTS (inside_init
);
4261 link
= TREE_CHAIN (link
))
4262 if (! CONSTANT_CLASS_P (TREE_VALUE (link
)))
4266 return build_vector (type
, CONSTRUCTOR_ELTS (inside_init
));
4270 /* Any type can be initialized
4271 from an expression of the same type, optionally with braces. */
4273 if (inside_init
&& TREE_TYPE (inside_init
) != 0
4274 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4275 TYPE_MAIN_VARIANT (type
))
4276 || (code
== ARRAY_TYPE
4277 && comptypes (TREE_TYPE (inside_init
), type
))
4278 || (code
== VECTOR_TYPE
4279 && comptypes (TREE_TYPE (inside_init
), type
))
4280 || (code
== POINTER_TYPE
4281 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
4282 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
4284 || (code
== POINTER_TYPE
4285 && TREE_CODE (TREE_TYPE (inside_init
)) == FUNCTION_TYPE
4286 && comptypes (TREE_TYPE (inside_init
),
4287 TREE_TYPE (type
)))))
4289 if (code
== POINTER_TYPE
)
4291 inside_init
= default_function_array_conversion (inside_init
);
4293 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
4295 error_init ("invalid use of non-lvalue array");
4296 return error_mark_node
;
4300 if (code
== VECTOR_TYPE
)
4301 /* Although the types are compatible, we may require a
4303 inside_init
= convert (type
, inside_init
);
4305 if (require_constant
&& !flag_isoc99
4306 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
4308 /* As an extension, allow initializing objects with static storage
4309 duration with compound literals (which are then treated just as
4310 the brace enclosed list they contain). */
4311 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
4312 inside_init
= DECL_INITIAL (decl
);
4315 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
4316 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
4318 error_init ("array initialized from non-constant array expression");
4319 return error_mark_node
;
4322 if (optimize
&& TREE_CODE (inside_init
) == VAR_DECL
)
4323 inside_init
= decl_constant_value_for_broken_optimization (inside_init
);
4325 /* Compound expressions can only occur here if -pedantic or
4326 -pedantic-errors is specified. In the later case, we always want
4327 an error. In the former case, we simply want a warning. */
4328 if (require_constant
&& pedantic
4329 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
4332 = valid_compound_expr_initializer (inside_init
,
4333 TREE_TYPE (inside_init
));
4334 if (inside_init
== error_mark_node
)
4335 error_init ("initializer element is not constant");
4337 pedwarn_init ("initializer element is not constant");
4338 if (flag_pedantic_errors
)
4339 inside_init
= error_mark_node
;
4341 else if (require_constant
4342 && !initializer_constant_valid_p (inside_init
,
4343 TREE_TYPE (inside_init
)))
4345 error_init ("initializer element is not constant");
4346 inside_init
= error_mark_node
;
4352 /* Handle scalar types, including conversions. */
4354 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
4355 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
4356 || code
== VECTOR_TYPE
)
4358 /* Note that convert_for_assignment calls default_conversion
4359 for arrays and functions. We must not call it in the
4360 case where inside_init is a null pointer constant. */
4362 = convert_for_assignment (type
, init
, ic_init
,
4363 NULL_TREE
, NULL_TREE
, 0);
4365 /* Check to see if we have already given an error message. */
4366 if (inside_init
== error_mark_node
)
4368 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
4370 error_init ("initializer element is not constant");
4371 inside_init
= error_mark_node
;
4373 else if (require_constant
4374 && !initializer_constant_valid_p (inside_init
,
4375 TREE_TYPE (inside_init
)))
4377 error_init ("initializer element is not computable at load time");
4378 inside_init
= error_mark_node
;
4384 /* Come here only for records and arrays. */
4386 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4388 error_init ("variable-sized object may not be initialized");
4389 return error_mark_node
;
4392 error_init ("invalid initializer");
4393 return error_mark_node
;
4396 /* Handle initializers that use braces. */
4398 /* Type of object we are accumulating a constructor for.
4399 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4400 static tree constructor_type
;
4402 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4404 static tree constructor_fields
;
4406 /* For an ARRAY_TYPE, this is the specified index
4407 at which to store the next element we get. */
4408 static tree constructor_index
;
4410 /* For an ARRAY_TYPE, this is the maximum index. */
4411 static tree constructor_max_index
;
4413 /* For a RECORD_TYPE, this is the first field not yet written out. */
4414 static tree constructor_unfilled_fields
;
4416 /* For an ARRAY_TYPE, this is the index of the first element
4417 not yet written out. */
4418 static tree constructor_unfilled_index
;
4420 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4421 This is so we can generate gaps between fields, when appropriate. */
4422 static tree constructor_bit_index
;
4424 /* If we are saving up the elements rather than allocating them,
4425 this is the list of elements so far (in reverse order,
4426 most recent first). */
4427 static tree constructor_elements
;
4429 /* 1 if constructor should be incrementally stored into a constructor chain,
4430 0 if all the elements should be kept in AVL tree. */
4431 static int constructor_incremental
;
4433 /* 1 if so far this constructor's elements are all compile-time constants. */
4434 static int constructor_constant
;
4436 /* 1 if so far this constructor's elements are all valid address constants. */
4437 static int constructor_simple
;
4439 /* 1 if this constructor is erroneous so far. */
4440 static int constructor_erroneous
;
4442 /* Structure for managing pending initializer elements, organized as an
4447 struct init_node
*left
, *right
;
4448 struct init_node
*parent
;
4454 /* Tree of pending elements at this constructor level.
4455 These are elements encountered out of order
4456 which belong at places we haven't reached yet in actually
4458 Will never hold tree nodes across GC runs. */
4459 static struct init_node
*constructor_pending_elts
;
4461 /* The SPELLING_DEPTH of this constructor. */
4462 static int constructor_depth
;
4464 /* DECL node for which an initializer is being read.
4465 0 means we are reading a constructor expression
4466 such as (struct foo) {...}. */
4467 static tree constructor_decl
;
4469 /* Nonzero if this is an initializer for a top-level decl. */
4470 static int constructor_top_level
;
4472 /* Nonzero if there were any member designators in this initializer. */
4473 static int constructor_designated
;
4475 /* Nesting depth of designator list. */
4476 static int designator_depth
;
4478 /* Nonzero if there were diagnosed errors in this designator list. */
4479 static int designator_errorneous
;
4482 /* This stack has a level for each implicit or explicit level of
4483 structuring in the initializer, including the outermost one. It
4484 saves the values of most of the variables above. */
4486 struct constructor_range_stack
;
4488 struct constructor_stack
4490 struct constructor_stack
*next
;
4495 tree unfilled_index
;
4496 tree unfilled_fields
;
4499 struct init_node
*pending_elts
;
4502 /* If value nonzero, this value should replace the entire
4503 constructor at this level. */
4504 struct c_expr replacement_value
;
4505 struct constructor_range_stack
*range_stack
;
4515 static struct constructor_stack
*constructor_stack
;
4517 /* This stack represents designators from some range designator up to
4518 the last designator in the list. */
4520 struct constructor_range_stack
4522 struct constructor_range_stack
*next
, *prev
;
4523 struct constructor_stack
*stack
;
4530 static struct constructor_range_stack
*constructor_range_stack
;
4532 /* This stack records separate initializers that are nested.
4533 Nested initializers can't happen in ANSI C, but GNU C allows them
4534 in cases like { ... (struct foo) { ... } ... }. */
4536 struct initializer_stack
4538 struct initializer_stack
*next
;
4540 struct constructor_stack
*constructor_stack
;
4541 struct constructor_range_stack
*constructor_range_stack
;
4543 struct spelling
*spelling
;
4544 struct spelling
*spelling_base
;
4547 char require_constant_value
;
4548 char require_constant_elements
;
4551 static struct initializer_stack
*initializer_stack
;
4553 /* Prepare to parse and output the initializer for variable DECL. */
4556 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
)
4559 struct initializer_stack
*p
= xmalloc (sizeof (struct initializer_stack
));
4561 p
->decl
= constructor_decl
;
4562 p
->require_constant_value
= require_constant_value
;
4563 p
->require_constant_elements
= require_constant_elements
;
4564 p
->constructor_stack
= constructor_stack
;
4565 p
->constructor_range_stack
= constructor_range_stack
;
4566 p
->elements
= constructor_elements
;
4567 p
->spelling
= spelling
;
4568 p
->spelling_base
= spelling_base
;
4569 p
->spelling_size
= spelling_size
;
4570 p
->top_level
= constructor_top_level
;
4571 p
->next
= initializer_stack
;
4572 initializer_stack
= p
;
4574 constructor_decl
= decl
;
4575 constructor_designated
= 0;
4576 constructor_top_level
= top_level
;
4578 if (decl
!= 0 && decl
!= error_mark_node
)
4580 require_constant_value
= TREE_STATIC (decl
);
4581 require_constant_elements
4582 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
4583 /* For a scalar, you can always use any value to initialize,
4584 even within braces. */
4585 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
4586 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
4587 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
4588 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
4589 locus
= IDENTIFIER_POINTER (DECL_NAME (decl
));
4593 require_constant_value
= 0;
4594 require_constant_elements
= 0;
4595 locus
= "(anonymous)";
4598 constructor_stack
= 0;
4599 constructor_range_stack
= 0;
4601 missing_braces_mentioned
= 0;
4605 RESTORE_SPELLING_DEPTH (0);
4608 push_string (locus
);
4614 struct initializer_stack
*p
= initializer_stack
;
4616 /* Free the whole constructor stack of this initializer. */
4617 while (constructor_stack
)
4619 struct constructor_stack
*q
= constructor_stack
;
4620 constructor_stack
= q
->next
;
4624 gcc_assert (!constructor_range_stack
);
4626 /* Pop back to the data of the outer initializer (if any). */
4627 free (spelling_base
);
4629 constructor_decl
= p
->decl
;
4630 require_constant_value
= p
->require_constant_value
;
4631 require_constant_elements
= p
->require_constant_elements
;
4632 constructor_stack
= p
->constructor_stack
;
4633 constructor_range_stack
= p
->constructor_range_stack
;
4634 constructor_elements
= p
->elements
;
4635 spelling
= p
->spelling
;
4636 spelling_base
= p
->spelling_base
;
4637 spelling_size
= p
->spelling_size
;
4638 constructor_top_level
= p
->top_level
;
4639 initializer_stack
= p
->next
;
4643 /* Call here when we see the initializer is surrounded by braces.
4644 This is instead of a call to push_init_level;
4645 it is matched by a call to pop_init_level.
4647 TYPE is the type to initialize, for a constructor expression.
4648 For an initializer for a decl, TYPE is zero. */
4651 really_start_incremental_init (tree type
)
4653 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
4656 type
= TREE_TYPE (constructor_decl
);
4658 if (targetm
.vector_opaque_p (type
))
4659 error ("opaque vector types cannot be initialized");
4661 p
->type
= constructor_type
;
4662 p
->fields
= constructor_fields
;
4663 p
->index
= constructor_index
;
4664 p
->max_index
= constructor_max_index
;
4665 p
->unfilled_index
= constructor_unfilled_index
;
4666 p
->unfilled_fields
= constructor_unfilled_fields
;
4667 p
->bit_index
= constructor_bit_index
;
4668 p
->elements
= constructor_elements
;
4669 p
->constant
= constructor_constant
;
4670 p
->simple
= constructor_simple
;
4671 p
->erroneous
= constructor_erroneous
;
4672 p
->pending_elts
= constructor_pending_elts
;
4673 p
->depth
= constructor_depth
;
4674 p
->replacement_value
.value
= 0;
4675 p
->replacement_value
.original_code
= ERROR_MARK
;
4679 p
->incremental
= constructor_incremental
;
4680 p
->designated
= constructor_designated
;
4682 constructor_stack
= p
;
4684 constructor_constant
= 1;
4685 constructor_simple
= 1;
4686 constructor_depth
= SPELLING_DEPTH ();
4687 constructor_elements
= 0;
4688 constructor_pending_elts
= 0;
4689 constructor_type
= type
;
4690 constructor_incremental
= 1;
4691 constructor_designated
= 0;
4692 designator_depth
= 0;
4693 designator_errorneous
= 0;
4695 if (TREE_CODE (constructor_type
) == RECORD_TYPE
4696 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4698 constructor_fields
= TYPE_FIELDS (constructor_type
);
4699 /* Skip any nameless bit fields at the beginning. */
4700 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
4701 && DECL_NAME (constructor_fields
) == 0)
4702 constructor_fields
= TREE_CHAIN (constructor_fields
);
4704 constructor_unfilled_fields
= constructor_fields
;
4705 constructor_bit_index
= bitsize_zero_node
;
4707 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4709 if (TYPE_DOMAIN (constructor_type
))
4711 constructor_max_index
4712 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
4714 /* Detect non-empty initializations of zero-length arrays. */
4715 if (constructor_max_index
== NULL_TREE
4716 && TYPE_SIZE (constructor_type
))
4717 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4719 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4720 to initialize VLAs will cause a proper error; avoid tree
4721 checking errors as well by setting a safe value. */
4722 if (constructor_max_index
4723 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
4724 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4727 = convert (bitsizetype
,
4728 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
4732 constructor_index
= bitsize_zero_node
;
4733 constructor_max_index
= NULL_TREE
;
4736 constructor_unfilled_index
= constructor_index
;
4738 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
4740 /* Vectors are like simple fixed-size arrays. */
4741 constructor_max_index
=
4742 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
4743 constructor_index
= convert (bitsizetype
, bitsize_zero_node
);
4744 constructor_unfilled_index
= constructor_index
;
4748 /* Handle the case of int x = {5}; */
4749 constructor_fields
= constructor_type
;
4750 constructor_unfilled_fields
= constructor_type
;
4754 /* Push down into a subobject, for initialization.
4755 If this is for an explicit set of braces, IMPLICIT is 0.
4756 If it is because the next element belongs at a lower level,
4757 IMPLICIT is 1 (or 2 if the push is because of designator list). */
4760 push_init_level (int implicit
)
4762 struct constructor_stack
*p
;
4763 tree value
= NULL_TREE
;
4765 /* If we've exhausted any levels that didn't have braces,
4767 while (constructor_stack
->implicit
)
4769 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
4770 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4771 && constructor_fields
== 0)
4772 process_init_element (pop_init_level (1));
4773 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
4774 && constructor_max_index
4775 && tree_int_cst_lt (constructor_max_index
, constructor_index
))
4776 process_init_element (pop_init_level (1));
4781 /* Unless this is an explicit brace, we need to preserve previous
4785 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
4786 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4787 && constructor_fields
)
4788 value
= find_init_member (constructor_fields
);
4789 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4790 value
= find_init_member (constructor_index
);
4793 p
= XNEW (struct constructor_stack
);
4794 p
->type
= constructor_type
;
4795 p
->fields
= constructor_fields
;
4796 p
->index
= constructor_index
;
4797 p
->max_index
= constructor_max_index
;
4798 p
->unfilled_index
= constructor_unfilled_index
;
4799 p
->unfilled_fields
= constructor_unfilled_fields
;
4800 p
->bit_index
= constructor_bit_index
;
4801 p
->elements
= constructor_elements
;
4802 p
->constant
= constructor_constant
;
4803 p
->simple
= constructor_simple
;
4804 p
->erroneous
= constructor_erroneous
;
4805 p
->pending_elts
= constructor_pending_elts
;
4806 p
->depth
= constructor_depth
;
4807 p
->replacement_value
.value
= 0;
4808 p
->replacement_value
.original_code
= ERROR_MARK
;
4809 p
->implicit
= implicit
;
4811 p
->incremental
= constructor_incremental
;
4812 p
->designated
= constructor_designated
;
4813 p
->next
= constructor_stack
;
4815 constructor_stack
= p
;
4817 constructor_constant
= 1;
4818 constructor_simple
= 1;
4819 constructor_depth
= SPELLING_DEPTH ();
4820 constructor_elements
= 0;
4821 constructor_incremental
= 1;
4822 constructor_designated
= 0;
4823 constructor_pending_elts
= 0;
4826 p
->range_stack
= constructor_range_stack
;
4827 constructor_range_stack
= 0;
4828 designator_depth
= 0;
4829 designator_errorneous
= 0;
4832 /* Don't die if an entire brace-pair level is superfluous
4833 in the containing level. */
4834 if (constructor_type
== 0)
4836 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
4837 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4839 /* Don't die if there are extra init elts at the end. */
4840 if (constructor_fields
== 0)
4841 constructor_type
= 0;
4844 constructor_type
= TREE_TYPE (constructor_fields
);
4845 push_member_name (constructor_fields
);
4846 constructor_depth
++;
4849 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4851 constructor_type
= TREE_TYPE (constructor_type
);
4852 push_array_bounds (tree_low_cst (constructor_index
, 0));
4853 constructor_depth
++;
4856 if (constructor_type
== 0)
4858 error_init ("extra brace group at end of initializer");
4859 constructor_fields
= 0;
4860 constructor_unfilled_fields
= 0;
4864 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
4866 constructor_constant
= TREE_CONSTANT (value
);
4867 constructor_simple
= TREE_STATIC (value
);
4868 constructor_elements
= CONSTRUCTOR_ELTS (value
);
4869 if (constructor_elements
4870 && (TREE_CODE (constructor_type
) == RECORD_TYPE
4871 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
4872 set_nonincremental_init ();
4875 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
4877 missing_braces_mentioned
= 1;
4878 warning_init ("missing braces around initializer");
4881 if (TREE_CODE (constructor_type
) == RECORD_TYPE
4882 || TREE_CODE (constructor_type
) == UNION_TYPE
)
4884 constructor_fields
= TYPE_FIELDS (constructor_type
);
4885 /* Skip any nameless bit fields at the beginning. */
4886 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
4887 && DECL_NAME (constructor_fields
) == 0)
4888 constructor_fields
= TREE_CHAIN (constructor_fields
);
4890 constructor_unfilled_fields
= constructor_fields
;
4891 constructor_bit_index
= bitsize_zero_node
;
4893 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
4895 /* Vectors are like simple fixed-size arrays. */
4896 constructor_max_index
=
4897 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
4898 constructor_index
= convert (bitsizetype
, integer_zero_node
);
4899 constructor_unfilled_index
= constructor_index
;
4901 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
4903 if (TYPE_DOMAIN (constructor_type
))
4905 constructor_max_index
4906 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
4908 /* Detect non-empty initializations of zero-length arrays. */
4909 if (constructor_max_index
== NULL_TREE
4910 && TYPE_SIZE (constructor_type
))
4911 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4913 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4914 to initialize VLAs will cause a proper error; avoid tree
4915 checking errors as well by setting a safe value. */
4916 if (constructor_max_index
4917 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
4918 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
4921 = convert (bitsizetype
,
4922 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
4925 constructor_index
= bitsize_zero_node
;
4927 constructor_unfilled_index
= constructor_index
;
4928 if (value
&& TREE_CODE (value
) == STRING_CST
)
4930 /* We need to split the char/wchar array into individual
4931 characters, so that we don't have to special case it
4933 set_nonincremental_init_from_string (value
);
4938 if (constructor_type
!= error_mark_node
)
4939 warning_init ("braces around scalar initializer");
4940 constructor_fields
= constructor_type
;
4941 constructor_unfilled_fields
= constructor_type
;
4945 /* At the end of an implicit or explicit brace level,
4946 finish up that level of constructor. If a single expression
4947 with redundant braces initialized that level, return the
4948 c_expr structure for that expression. Otherwise, the original_code
4949 element is set to ERROR_MARK.
4950 If we were outputting the elements as they are read, return 0 as the value
4951 from inner levels (process_init_element ignores that),
4952 but return error_mark_node as the value from the outermost level
4953 (that's what we want to put in DECL_INITIAL).
4954 Otherwise, return a CONSTRUCTOR expression as the value. */
4957 pop_init_level (int implicit
)
4959 struct constructor_stack
*p
;
4962 ret
.original_code
= ERROR_MARK
;
4966 /* When we come to an explicit close brace,
4967 pop any inner levels that didn't have explicit braces. */
4968 while (constructor_stack
->implicit
)
4969 process_init_element (pop_init_level (1));
4971 gcc_assert (!constructor_range_stack
);
4974 /* Now output all pending elements. */
4975 constructor_incremental
= 1;
4976 output_pending_init_elements (1);
4978 p
= constructor_stack
;
4980 /* Error for initializing a flexible array member, or a zero-length
4981 array member in an inappropriate context. */
4982 if (constructor_type
&& constructor_fields
4983 && TREE_CODE (constructor_type
) == ARRAY_TYPE
4984 && TYPE_DOMAIN (constructor_type
)
4985 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
4987 /* Silently discard empty initializations. The parser will
4988 already have pedwarned for empty brackets. */
4989 if (integer_zerop (constructor_unfilled_index
))
4990 constructor_type
= NULL_TREE
;
4993 gcc_assert (!TYPE_SIZE (constructor_type
));
4995 if (constructor_depth
> 2)
4996 error_init ("initialization of flexible array member in a nested context");
4998 pedwarn_init ("initialization of a flexible array member");
5000 /* We have already issued an error message for the existence
5001 of a flexible array member not at the end of the structure.
5002 Discard the initializer so that we do not abort later. */
5003 if (TREE_CHAIN (constructor_fields
) != NULL_TREE
)
5004 constructor_type
= NULL_TREE
;
5008 /* Warn when some struct elements are implicitly initialized to zero. */
5009 if (warn_missing_field_initializers
5011 && TREE_CODE (constructor_type
) == RECORD_TYPE
5012 && constructor_unfilled_fields
)
5014 /* Do not warn for flexible array members or zero-length arrays. */
5015 while (constructor_unfilled_fields
5016 && (!DECL_SIZE (constructor_unfilled_fields
)
5017 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
5018 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
5020 /* Do not warn if this level of the initializer uses member
5021 designators; it is likely to be deliberate. */
5022 if (constructor_unfilled_fields
&& !constructor_designated
)
5024 push_member_name (constructor_unfilled_fields
);
5025 warning_init ("missing initializer");
5026 RESTORE_SPELLING_DEPTH (constructor_depth
);
5030 /* Pad out the end of the structure. */
5031 if (p
->replacement_value
.value
)
5032 /* If this closes a superfluous brace pair,
5033 just pass out the element between them. */
5034 ret
= p
->replacement_value
;
5035 else if (constructor_type
== 0)
5037 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
5038 && TREE_CODE (constructor_type
) != UNION_TYPE
5039 && TREE_CODE (constructor_type
) != ARRAY_TYPE
5040 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
5042 /* A nonincremental scalar initializer--just return
5043 the element, after verifying there is just one. */
5044 if (constructor_elements
== 0)
5046 if (!constructor_erroneous
)
5047 error_init ("empty scalar initializer");
5048 ret
.value
= error_mark_node
;
5050 else if (TREE_CHAIN (constructor_elements
) != 0)
5052 error_init ("extra elements in scalar initializer");
5053 ret
.value
= TREE_VALUE (constructor_elements
);
5056 ret
.value
= TREE_VALUE (constructor_elements
);
5060 if (constructor_erroneous
)
5061 ret
.value
= error_mark_node
;
5064 ret
.value
= build_constructor (constructor_type
,
5065 nreverse (constructor_elements
));
5066 if (constructor_constant
)
5067 TREE_CONSTANT (ret
.value
) = TREE_INVARIANT (ret
.value
) = 1;
5068 if (constructor_constant
&& constructor_simple
)
5069 TREE_STATIC (ret
.value
) = 1;
5073 constructor_type
= p
->type
;
5074 constructor_fields
= p
->fields
;
5075 constructor_index
= p
->index
;
5076 constructor_max_index
= p
->max_index
;
5077 constructor_unfilled_index
= p
->unfilled_index
;
5078 constructor_unfilled_fields
= p
->unfilled_fields
;
5079 constructor_bit_index
= p
->bit_index
;
5080 constructor_elements
= p
->elements
;
5081 constructor_constant
= p
->constant
;
5082 constructor_simple
= p
->simple
;
5083 constructor_erroneous
= p
->erroneous
;
5084 constructor_incremental
= p
->incremental
;
5085 constructor_designated
= p
->designated
;
5086 constructor_pending_elts
= p
->pending_elts
;
5087 constructor_depth
= p
->depth
;
5089 constructor_range_stack
= p
->range_stack
;
5090 RESTORE_SPELLING_DEPTH (constructor_depth
);
5092 constructor_stack
= p
->next
;
5097 if (constructor_stack
== 0)
5099 ret
.value
= error_mark_node
;
5107 /* Common handling for both array range and field name designators.
5108 ARRAY argument is nonzero for array ranges. Returns zero for success. */
5111 set_designator (int array
)
5114 enum tree_code subcode
;
5116 /* Don't die if an entire brace-pair level is superfluous
5117 in the containing level. */
5118 if (constructor_type
== 0)
5121 /* If there were errors in this designator list already, bail out
5123 if (designator_errorneous
)
5126 if (!designator_depth
)
5128 gcc_assert (!constructor_range_stack
);
5130 /* Designator list starts at the level of closest explicit
5132 while (constructor_stack
->implicit
)
5133 process_init_element (pop_init_level (1));
5134 constructor_designated
= 1;
5138 switch (TREE_CODE (constructor_type
))
5142 subtype
= TREE_TYPE (constructor_fields
);
5143 if (subtype
!= error_mark_node
)
5144 subtype
= TYPE_MAIN_VARIANT (subtype
);
5147 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
5153 subcode
= TREE_CODE (subtype
);
5154 if (array
&& subcode
!= ARRAY_TYPE
)
5156 error_init ("array index in non-array initializer");
5159 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
5161 error_init ("field name not in record or union initializer");
5165 constructor_designated
= 1;
5166 push_init_level (2);
5170 /* If there are range designators in designator list, push a new designator
5171 to constructor_range_stack. RANGE_END is end of such stack range or
5172 NULL_TREE if there is no range designator at this level. */
5175 push_range_stack (tree range_end
)
5177 struct constructor_range_stack
*p
;
5179 p
= GGC_NEW (struct constructor_range_stack
);
5180 p
->prev
= constructor_range_stack
;
5182 p
->fields
= constructor_fields
;
5183 p
->range_start
= constructor_index
;
5184 p
->index
= constructor_index
;
5185 p
->stack
= constructor_stack
;
5186 p
->range_end
= range_end
;
5187 if (constructor_range_stack
)
5188 constructor_range_stack
->next
= p
;
5189 constructor_range_stack
= p
;
5192 /* Within an array initializer, specify the next index to be initialized.
5193 FIRST is that index. If LAST is nonzero, then initialize a range
5194 of indices, running from FIRST through LAST. */
5197 set_init_index (tree first
, tree last
)
5199 if (set_designator (1))
5202 designator_errorneous
= 1;
5204 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
5205 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
5207 error_init ("array index in initializer not of integer type");
5211 while ((TREE_CODE (first
) == NOP_EXPR
5212 || TREE_CODE (first
) == CONVERT_EXPR
5213 || TREE_CODE (first
) == NON_LVALUE_EXPR
)
5214 && (TYPE_MODE (TREE_TYPE (first
))
5215 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first
, 0)))))
5216 first
= TREE_OPERAND (first
, 0);
5219 while ((TREE_CODE (last
) == NOP_EXPR
5220 || TREE_CODE (last
) == CONVERT_EXPR
5221 || TREE_CODE (last
) == NON_LVALUE_EXPR
)
5222 && (TYPE_MODE (TREE_TYPE (last
))
5223 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last
, 0)))))
5224 last
= TREE_OPERAND (last
, 0);
5226 if (TREE_CODE (first
) != INTEGER_CST
)
5227 error_init ("nonconstant array index in initializer");
5228 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
5229 error_init ("nonconstant array index in initializer");
5230 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5231 error_init ("array index in non-array initializer");
5232 else if (tree_int_cst_sgn (first
) == -1)
5233 error_init ("array index in initializer exceeds array bounds");
5234 else if (constructor_max_index
5235 && tree_int_cst_lt (constructor_max_index
, first
))
5236 error_init ("array index in initializer exceeds array bounds");
5239 constructor_index
= convert (bitsizetype
, first
);
5243 if (tree_int_cst_equal (first
, last
))
5245 else if (tree_int_cst_lt (last
, first
))
5247 error_init ("empty index range in initializer");
5252 last
= convert (bitsizetype
, last
);
5253 if (constructor_max_index
!= 0
5254 && tree_int_cst_lt (constructor_max_index
, last
))
5256 error_init ("array index range in initializer exceeds array bounds");
5263 designator_errorneous
= 0;
5264 if (constructor_range_stack
|| last
)
5265 push_range_stack (last
);
5269 /* Within a struct initializer, specify the next field to be initialized. */
5272 set_init_label (tree fieldname
)
5276 if (set_designator (0))
5279 designator_errorneous
= 1;
5281 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5282 && TREE_CODE (constructor_type
) != UNION_TYPE
)
5284 error_init ("field name not in record or union initializer");
5288 for (tail
= TYPE_FIELDS (constructor_type
); tail
;
5289 tail
= TREE_CHAIN (tail
))
5291 if (DECL_NAME (tail
) == fieldname
)
5296 error ("unknown field %qs specified in initializer",
5297 IDENTIFIER_POINTER (fieldname
));
5300 constructor_fields
= tail
;
5302 designator_errorneous
= 0;
5303 if (constructor_range_stack
)
5304 push_range_stack (NULL_TREE
);
5308 /* Add a new initializer to the tree of pending initializers. PURPOSE
5309 identifies the initializer, either array index or field in a structure.
5310 VALUE is the value of that index or field. */
5313 add_pending_init (tree purpose
, tree value
)
5315 struct init_node
*p
, **q
, *r
;
5317 q
= &constructor_pending_elts
;
5320 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5325 if (tree_int_cst_lt (purpose
, p
->purpose
))
5327 else if (tree_int_cst_lt (p
->purpose
, purpose
))
5331 if (TREE_SIDE_EFFECTS (p
->value
))
5332 warning_init ("initialized field with side-effects overwritten");
5342 bitpos
= bit_position (purpose
);
5346 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5348 else if (p
->purpose
!= purpose
)
5352 if (TREE_SIDE_EFFECTS (p
->value
))
5353 warning_init ("initialized field with side-effects overwritten");
5360 r
= GGC_NEW (struct init_node
);
5361 r
->purpose
= purpose
;
5372 struct init_node
*s
;
5376 if (p
->balance
== 0)
5378 else if (p
->balance
< 0)
5385 p
->left
->parent
= p
;
5402 constructor_pending_elts
= r
;
5407 struct init_node
*t
= r
->right
;
5411 r
->right
->parent
= r
;
5416 p
->left
->parent
= p
;
5419 p
->balance
= t
->balance
< 0;
5420 r
->balance
= -(t
->balance
> 0);
5435 constructor_pending_elts
= t
;
5441 /* p->balance == +1; growth of left side balances the node. */
5446 else /* r == p->right */
5448 if (p
->balance
== 0)
5449 /* Growth propagation from right side. */
5451 else if (p
->balance
> 0)
5458 p
->right
->parent
= p
;
5475 constructor_pending_elts
= r
;
5477 else /* r->balance == -1 */
5480 struct init_node
*t
= r
->left
;
5484 r
->left
->parent
= r
;
5489 p
->right
->parent
= p
;
5492 r
->balance
= (t
->balance
< 0);
5493 p
->balance
= -(t
->balance
> 0);
5508 constructor_pending_elts
= t
;
5514 /* p->balance == -1; growth of right side balances the node. */
5525 /* Build AVL tree from a sorted chain. */
5528 set_nonincremental_init (void)
5532 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5533 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5536 for (chain
= constructor_elements
; chain
; chain
= TREE_CHAIN (chain
))
5537 add_pending_init (TREE_PURPOSE (chain
), TREE_VALUE (chain
));
5538 constructor_elements
= 0;
5539 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5541 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
5542 /* Skip any nameless bit fields at the beginning. */
5543 while (constructor_unfilled_fields
!= 0
5544 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
5545 && DECL_NAME (constructor_unfilled_fields
) == 0)
5546 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
5549 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5551 if (TYPE_DOMAIN (constructor_type
))
5552 constructor_unfilled_index
5553 = convert (bitsizetype
,
5554 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
5556 constructor_unfilled_index
= bitsize_zero_node
;
5558 constructor_incremental
= 0;
5561 /* Build AVL tree from a string constant. */
5564 set_nonincremental_init_from_string (tree str
)
5566 tree value
, purpose
, type
;
5567 HOST_WIDE_INT val
[2];
5568 const char *p
, *end
;
5569 int byte
, wchar_bytes
, charwidth
, bitpos
;
5571 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
5573 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
5574 == TYPE_PRECISION (char_type_node
))
5578 gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
5579 == TYPE_PRECISION (wchar_type_node
));
5580 wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
5582 charwidth
= TYPE_PRECISION (char_type_node
);
5583 type
= TREE_TYPE (constructor_type
);
5584 p
= TREE_STRING_POINTER (str
);
5585 end
= p
+ TREE_STRING_LENGTH (str
);
5587 for (purpose
= bitsize_zero_node
;
5588 p
< end
&& !tree_int_cst_lt (constructor_max_index
, purpose
);
5589 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
5591 if (wchar_bytes
== 1)
5593 val
[1] = (unsigned char) *p
++;
5600 for (byte
= 0; byte
< wchar_bytes
; byte
++)
5602 if (BYTES_BIG_ENDIAN
)
5603 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
5605 bitpos
= byte
* charwidth
;
5606 val
[bitpos
< HOST_BITS_PER_WIDE_INT
]
5607 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
5608 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
5612 if (!TYPE_UNSIGNED (type
))
5614 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
5615 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5617 if (val
[1] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
5619 val
[1] |= ((HOST_WIDE_INT
) -1) << bitpos
;
5623 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
5628 else if (val
[0] & (((HOST_WIDE_INT
) 1)
5629 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
5630 val
[0] |= ((HOST_WIDE_INT
) -1)
5631 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5634 value
= build_int_cst_wide (type
, val
[1], val
[0]);
5635 add_pending_init (purpose
, value
);
5638 constructor_incremental
= 0;
5641 /* Return value of FIELD in pending initializer or zero if the field was
5642 not initialized yet. */
5645 find_init_member (tree field
)
5647 struct init_node
*p
;
5649 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5651 if (constructor_incremental
5652 && tree_int_cst_lt (field
, constructor_unfilled_index
))
5653 set_nonincremental_init ();
5655 p
= constructor_pending_elts
;
5658 if (tree_int_cst_lt (field
, p
->purpose
))
5660 else if (tree_int_cst_lt (p
->purpose
, field
))
5666 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5668 tree bitpos
= bit_position (field
);
5670 if (constructor_incremental
5671 && (!constructor_unfilled_fields
5672 || tree_int_cst_lt (bitpos
,
5673 bit_position (constructor_unfilled_fields
))))
5674 set_nonincremental_init ();
5676 p
= constructor_pending_elts
;
5679 if (field
== p
->purpose
)
5681 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5687 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
5689 if (constructor_elements
5690 && TREE_PURPOSE (constructor_elements
) == field
)
5691 return TREE_VALUE (constructor_elements
);
5696 /* "Output" the next constructor element.
5697 At top level, really output it to assembler code now.
5698 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5699 TYPE is the data type that the containing data type wants here.
5700 FIELD is the field (a FIELD_DECL) or the index that this element fills.
5701 If VALUE is a string constant, STRICT_STRING is true if it is
5702 unparenthesized or we should not warn here for it being parenthesized.
5703 For other types of VALUE, STRICT_STRING is not used.
5705 PENDING if non-nil means output pending elements that belong
5706 right after this element. (PENDING is normally 1;
5707 it is 0 while outputting pending elements, to avoid recursion.) */
5710 output_init_element (tree value
, bool strict_string
, tree type
, tree field
,
5713 if (type
== error_mark_node
|| value
== error_mark_node
)
5715 constructor_erroneous
= 1;
5718 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
5719 || (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
5720 && !(TREE_CODE (value
) == STRING_CST
5721 && TREE_CODE (type
) == ARRAY_TYPE
5722 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
5723 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
5724 TYPE_MAIN_VARIANT (type
))))
5725 value
= default_conversion (value
);
5727 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
5728 && require_constant_value
&& !flag_isoc99
&& pending
)
5730 /* As an extension, allow initializing objects with static storage
5731 duration with compound literals (which are then treated just as
5732 the brace enclosed list they contain). */
5733 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
5734 value
= DECL_INITIAL (decl
);
5737 if (value
== error_mark_node
)
5738 constructor_erroneous
= 1;
5739 else if (!TREE_CONSTANT (value
))
5740 constructor_constant
= 0;
5741 else if (!initializer_constant_valid_p (value
, TREE_TYPE (value
))
5742 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
5743 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5744 && DECL_C_BIT_FIELD (field
)
5745 && TREE_CODE (value
) != INTEGER_CST
))
5746 constructor_simple
= 0;
5748 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
5750 if (require_constant_value
)
5752 error_init ("initializer element is not constant");
5753 value
= error_mark_node
;
5755 else if (require_constant_elements
)
5756 pedwarn ("initializer element is not computable at load time");
5759 /* If this field is empty (and not at the end of structure),
5760 don't do anything other than checking the initializer. */
5762 && (TREE_TYPE (field
) == error_mark_node
5763 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
5764 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
5765 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
5766 || TREE_CHAIN (field
)))))
5769 value
= digest_init (type
, value
, strict_string
, require_constant_value
);
5770 if (value
== error_mark_node
)
5772 constructor_erroneous
= 1;
5776 /* If this element doesn't come next in sequence,
5777 put it on constructor_pending_elts. */
5778 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
5779 && (!constructor_incremental
5780 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
5782 if (constructor_incremental
5783 && tree_int_cst_lt (field
, constructor_unfilled_index
))
5784 set_nonincremental_init ();
5786 add_pending_init (field
, value
);
5789 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5790 && (!constructor_incremental
5791 || field
!= constructor_unfilled_fields
))
5793 /* We do this for records but not for unions. In a union,
5794 no matter which field is specified, it can be initialized
5795 right away since it starts at the beginning of the union. */
5796 if (constructor_incremental
)
5798 if (!constructor_unfilled_fields
)
5799 set_nonincremental_init ();
5802 tree bitpos
, unfillpos
;
5804 bitpos
= bit_position (field
);
5805 unfillpos
= bit_position (constructor_unfilled_fields
);
5807 if (tree_int_cst_lt (bitpos
, unfillpos
))
5808 set_nonincremental_init ();
5812 add_pending_init (field
, value
);
5815 else if (TREE_CODE (constructor_type
) == UNION_TYPE
5816 && constructor_elements
)
5818 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements
)))
5819 warning_init ("initialized field with side-effects overwritten");
5821 /* We can have just one union field set. */
5822 constructor_elements
= 0;
5825 /* Otherwise, output this element either to
5826 constructor_elements or to the assembler file. */
5828 if (field
&& TREE_CODE (field
) == INTEGER_CST
)
5829 field
= copy_node (field
);
5830 constructor_elements
5831 = tree_cons (field
, value
, constructor_elements
);
5833 /* Advance the variable that indicates sequential elements output. */
5834 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5835 constructor_unfilled_index
5836 = size_binop (PLUS_EXPR
, constructor_unfilled_index
,
5838 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
5840 constructor_unfilled_fields
5841 = TREE_CHAIN (constructor_unfilled_fields
);
5843 /* Skip any nameless bit fields. */
5844 while (constructor_unfilled_fields
!= 0
5845 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
5846 && DECL_NAME (constructor_unfilled_fields
) == 0)
5847 constructor_unfilled_fields
=
5848 TREE_CHAIN (constructor_unfilled_fields
);
5850 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
5851 constructor_unfilled_fields
= 0;
5853 /* Now output any pending elements which have become next. */
5855 output_pending_init_elements (0);
5858 /* Output any pending elements which have become next.
5859 As we output elements, constructor_unfilled_{fields,index}
5860 advances, which may cause other elements to become next;
5861 if so, they too are output.
5863 If ALL is 0, we return when there are
5864 no more pending elements to output now.
5866 If ALL is 1, we output space as necessary so that
5867 we can output all the pending elements. */
5870 output_pending_init_elements (int all
)
5872 struct init_node
*elt
= constructor_pending_elts
;
5877 /* Look through the whole pending tree.
5878 If we find an element that should be output now,
5879 output it. Otherwise, set NEXT to the element
5880 that comes first among those still pending. */
5885 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5887 if (tree_int_cst_equal (elt
->purpose
,
5888 constructor_unfilled_index
))
5889 output_init_element (elt
->value
, true,
5890 TREE_TYPE (constructor_type
),
5891 constructor_unfilled_index
, 0);
5892 else if (tree_int_cst_lt (constructor_unfilled_index
,
5895 /* Advance to the next smaller node. */
5900 /* We have reached the smallest node bigger than the
5901 current unfilled index. Fill the space first. */
5902 next
= elt
->purpose
;
5908 /* Advance to the next bigger node. */
5913 /* We have reached the biggest node in a subtree. Find
5914 the parent of it, which is the next bigger node. */
5915 while (elt
->parent
&& elt
->parent
->right
== elt
)
5918 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
5921 next
= elt
->purpose
;
5927 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5928 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5930 tree ctor_unfilled_bitpos
, elt_bitpos
;
5932 /* If the current record is complete we are done. */
5933 if (constructor_unfilled_fields
== 0)
5936 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
5937 elt_bitpos
= bit_position (elt
->purpose
);
5938 /* We can't compare fields here because there might be empty
5939 fields in between. */
5940 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
5942 constructor_unfilled_fields
= elt
->purpose
;
5943 output_init_element (elt
->value
, true, TREE_TYPE (elt
->purpose
),
5946 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
5948 /* Advance to the next smaller node. */
5953 /* We have reached the smallest node bigger than the
5954 current unfilled field. Fill the space first. */
5955 next
= elt
->purpose
;
5961 /* Advance to the next bigger node. */
5966 /* We have reached the biggest node in a subtree. Find
5967 the parent of it, which is the next bigger node. */
5968 while (elt
->parent
&& elt
->parent
->right
== elt
)
5972 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
5973 bit_position (elt
->purpose
))))
5975 next
= elt
->purpose
;
5983 /* Ordinarily return, but not if we want to output all
5984 and there are elements left. */
5985 if (!(all
&& next
!= 0))
5988 /* If it's not incremental, just skip over the gap, so that after
5989 jumping to retry we will output the next successive element. */
5990 if (TREE_CODE (constructor_type
) == RECORD_TYPE
5991 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5992 constructor_unfilled_fields
= next
;
5993 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5994 constructor_unfilled_index
= next
;
5996 /* ELT now points to the node in the pending tree with the next
5997 initializer to output. */
6001 /* Add one non-braced element to the current constructor level.
6002 This adjusts the current position within the constructor's type.
6003 This may also start or terminate implicit levels
6004 to handle a partly-braced initializer.
6006 Once this has found the correct level for the new element,
6007 it calls output_init_element. */
6010 process_init_element (struct c_expr value
)
6012 tree orig_value
= value
.value
;
6013 int string_flag
= orig_value
!= 0 && TREE_CODE (orig_value
) == STRING_CST
;
6014 bool strict_string
= value
.original_code
== STRING_CST
;
6016 designator_depth
= 0;
6017 designator_errorneous
= 0;
6019 /* Handle superfluous braces around string cst as in
6020 char x[] = {"foo"}; */
6023 && TREE_CODE (constructor_type
) == ARRAY_TYPE
6024 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
6025 && integer_zerop (constructor_unfilled_index
))
6027 if (constructor_stack
->replacement_value
.value
)
6028 error_init ("excess elements in char array initializer");
6029 constructor_stack
->replacement_value
= value
;
6033 if (constructor_stack
->replacement_value
.value
!= 0)
6035 error_init ("excess elements in struct initializer");
6039 /* Ignore elements of a brace group if it is entirely superfluous
6040 and has already been diagnosed. */
6041 if (constructor_type
== 0)
6044 /* If we've exhausted any levels that didn't have braces,
6046 while (constructor_stack
->implicit
)
6048 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6049 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6050 && constructor_fields
== 0)
6051 process_init_element (pop_init_level (1));
6052 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
6053 && (constructor_max_index
== 0
6054 || tree_int_cst_lt (constructor_max_index
,
6055 constructor_index
)))
6056 process_init_element (pop_init_level (1));
6061 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6062 if (constructor_range_stack
)
6064 /* If value is a compound literal and we'll be just using its
6065 content, don't put it into a SAVE_EXPR. */
6066 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
6067 || !require_constant_value
6069 value
.value
= save_expr (value
.value
);
6074 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
6077 enum tree_code fieldcode
;
6079 if (constructor_fields
== 0)
6081 pedwarn_init ("excess elements in struct initializer");
6085 fieldtype
= TREE_TYPE (constructor_fields
);
6086 if (fieldtype
!= error_mark_node
)
6087 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6088 fieldcode
= TREE_CODE (fieldtype
);
6090 /* Error for non-static initialization of a flexible array member. */
6091 if (fieldcode
== ARRAY_TYPE
6092 && !require_constant_value
6093 && TYPE_SIZE (fieldtype
) == NULL_TREE
6094 && TREE_CHAIN (constructor_fields
) == NULL_TREE
)
6096 error_init ("non-static initialization of a flexible array member");
6100 /* Accept a string constant to initialize a subarray. */
6101 if (value
.value
!= 0
6102 && fieldcode
== ARRAY_TYPE
6103 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
6105 value
.value
= orig_value
;
6106 /* Otherwise, if we have come to a subaggregate,
6107 and we don't have an element of its type, push into it. */
6108 else if (value
.value
!= 0
6109 && value
.value
!= error_mark_node
6110 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
6111 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6112 || fieldcode
== UNION_TYPE
))
6114 push_init_level (1);
6120 push_member_name (constructor_fields
);
6121 output_init_element (value
.value
, strict_string
,
6122 fieldtype
, constructor_fields
, 1);
6123 RESTORE_SPELLING_DEPTH (constructor_depth
);
6126 /* Do the bookkeeping for an element that was
6127 directly output as a constructor. */
6129 /* For a record, keep track of end position of last field. */
6130 if (DECL_SIZE (constructor_fields
))
6131 constructor_bit_index
6132 = size_binop (PLUS_EXPR
,
6133 bit_position (constructor_fields
),
6134 DECL_SIZE (constructor_fields
));
6136 /* If the current field was the first one not yet written out,
6137 it isn't now, so update. */
6138 if (constructor_unfilled_fields
== constructor_fields
)
6140 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6141 /* Skip any nameless bit fields. */
6142 while (constructor_unfilled_fields
!= 0
6143 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
6144 && DECL_NAME (constructor_unfilled_fields
) == 0)
6145 constructor_unfilled_fields
=
6146 TREE_CHAIN (constructor_unfilled_fields
);
6150 constructor_fields
= TREE_CHAIN (constructor_fields
);
6151 /* Skip any nameless bit fields at the beginning. */
6152 while (constructor_fields
!= 0
6153 && DECL_C_BIT_FIELD (constructor_fields
)
6154 && DECL_NAME (constructor_fields
) == 0)
6155 constructor_fields
= TREE_CHAIN (constructor_fields
);
6157 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
6160 enum tree_code fieldcode
;
6162 if (constructor_fields
== 0)
6164 pedwarn_init ("excess elements in union initializer");
6168 fieldtype
= TREE_TYPE (constructor_fields
);
6169 if (fieldtype
!= error_mark_node
)
6170 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6171 fieldcode
= TREE_CODE (fieldtype
);
6173 /* Warn that traditional C rejects initialization of unions.
6174 We skip the warning if the value is zero. This is done
6175 under the assumption that the zero initializer in user
6176 code appears conditioned on e.g. __STDC__ to avoid
6177 "missing initializer" warnings and relies on default
6178 initialization to zero in the traditional C case.
6179 We also skip the warning if the initializer is designated,
6180 again on the assumption that this must be conditional on
6181 __STDC__ anyway (and we've already complained about the
6182 member-designator already). */
6183 if (warn_traditional
&& !in_system_header
&& !constructor_designated
6184 && !(value
.value
&& (integer_zerop (value
.value
)
6185 || real_zerop (value
.value
))))
6186 warning ("traditional C rejects initialization of unions");
6188 /* Accept a string constant to initialize a subarray. */
6189 if (value
.value
!= 0
6190 && fieldcode
== ARRAY_TYPE
6191 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
6193 value
.value
= orig_value
;
6194 /* Otherwise, if we have come to a subaggregate,
6195 and we don't have an element of its type, push into it. */
6196 else if (value
.value
!= 0
6197 && value
.value
!= error_mark_node
6198 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
6199 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6200 || fieldcode
== UNION_TYPE
))
6202 push_init_level (1);
6208 push_member_name (constructor_fields
);
6209 output_init_element (value
.value
, strict_string
,
6210 fieldtype
, constructor_fields
, 1);
6211 RESTORE_SPELLING_DEPTH (constructor_depth
);
6214 /* Do the bookkeeping for an element that was
6215 directly output as a constructor. */
6217 constructor_bit_index
= DECL_SIZE (constructor_fields
);
6218 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6221 constructor_fields
= 0;
6223 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6225 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6226 enum tree_code eltcode
= TREE_CODE (elttype
);
6228 /* Accept a string constant to initialize a subarray. */
6229 if (value
.value
!= 0
6230 && eltcode
== ARRAY_TYPE
6231 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
6233 value
.value
= orig_value
;
6234 /* Otherwise, if we have come to a subaggregate,
6235 and we don't have an element of its type, push into it. */
6236 else if (value
.value
!= 0
6237 && value
.value
!= error_mark_node
6238 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
6239 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
6240 || eltcode
== UNION_TYPE
))
6242 push_init_level (1);
6246 if (constructor_max_index
!= 0
6247 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
6248 || integer_all_onesp (constructor_max_index
)))
6250 pedwarn_init ("excess elements in array initializer");
6254 /* Now output the actual element. */
6257 push_array_bounds (tree_low_cst (constructor_index
, 0));
6258 output_init_element (value
.value
, strict_string
,
6259 elttype
, constructor_index
, 1);
6260 RESTORE_SPELLING_DEPTH (constructor_depth
);
6264 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6267 /* If we are doing the bookkeeping for an element that was
6268 directly output as a constructor, we must update
6269 constructor_unfilled_index. */
6270 constructor_unfilled_index
= constructor_index
;
6272 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6274 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6276 /* Do a basic check of initializer size. Note that vectors
6277 always have a fixed size derived from their type. */
6278 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
6280 pedwarn_init ("excess elements in vector initializer");
6284 /* Now output the actual element. */
6286 output_init_element (value
.value
, strict_string
,
6287 elttype
, constructor_index
, 1);
6290 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6293 /* If we are doing the bookkeeping for an element that was
6294 directly output as a constructor, we must update
6295 constructor_unfilled_index. */
6296 constructor_unfilled_index
= constructor_index
;
6299 /* Handle the sole element allowed in a braced initializer
6300 for a scalar variable. */
6301 else if (constructor_type
!= error_mark_node
6302 && constructor_fields
== 0)
6304 pedwarn_init ("excess elements in scalar initializer");
6310 output_init_element (value
.value
, strict_string
,
6311 constructor_type
, NULL_TREE
, 1);
6312 constructor_fields
= 0;
6315 /* Handle range initializers either at this level or anywhere higher
6316 in the designator stack. */
6317 if (constructor_range_stack
)
6319 struct constructor_range_stack
*p
, *range_stack
;
6322 range_stack
= constructor_range_stack
;
6323 constructor_range_stack
= 0;
6324 while (constructor_stack
!= range_stack
->stack
)
6326 gcc_assert (constructor_stack
->implicit
);
6327 process_init_element (pop_init_level (1));
6329 for (p
= range_stack
;
6330 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
6333 gcc_assert (constructor_stack
->implicit
);
6334 process_init_element (pop_init_level (1));
6337 p
->index
= size_binop (PLUS_EXPR
, p
->index
, bitsize_one_node
);
6338 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
6343 constructor_index
= p
->index
;
6344 constructor_fields
= p
->fields
;
6345 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
6353 push_init_level (2);
6354 p
->stack
= constructor_stack
;
6355 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
6356 p
->index
= p
->range_start
;
6360 constructor_range_stack
= range_stack
;
6367 constructor_range_stack
= 0;
6370 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6371 (guaranteed to be 'volatile' or null) and ARGS (represented using
6372 an ASM_EXPR node). */
6374 build_asm_stmt (tree cv_qualifier
, tree args
)
6376 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
6377 ASM_VOLATILE_P (args
) = 1;
6378 return add_stmt (args
);
6381 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6382 some INPUTS, and some CLOBBERS. The latter three may be NULL.
6383 SIMPLE indicates whether there was anything at all after the
6384 string in the asm expression -- asm("blah") and asm("blah" : )
6385 are subtly different. We use a ASM_EXPR node to represent this. */
6387 build_asm_expr (tree string
, tree outputs
, tree inputs
, tree clobbers
,
6393 const char *constraint
;
6394 const char **oconstraints
;
6395 bool allows_mem
, allows_reg
, is_inout
;
6396 int ninputs
, noutputs
;
6398 ninputs
= list_length (inputs
);
6399 noutputs
= list_length (outputs
);
6400 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
6402 string
= resolve_asm_operand_names (string
, outputs
, inputs
);
6404 /* Remove output conversions that change the type but not the mode. */
6405 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
6407 tree output
= TREE_VALUE (tail
);
6409 /* ??? Really, this should not be here. Users should be using a
6410 proper lvalue, dammit. But there's a long history of using casts
6411 in the output operands. In cases like longlong.h, this becomes a
6412 primitive form of typechecking -- if the cast can be removed, then
6413 the output operand had a type of the proper width; otherwise we'll
6414 get an error. Gross, but ... */
6415 STRIP_NOPS (output
);
6417 if (!lvalue_or_else (output
, lv_asm
))
6418 output
= error_mark_node
;
6420 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
6421 oconstraints
[i
] = constraint
;
6423 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
6424 &allows_mem
, &allows_reg
, &is_inout
))
6426 /* If the operand is going to end up in memory,
6427 mark it addressable. */
6428 if (!allows_reg
&& !c_mark_addressable (output
))
6429 output
= error_mark_node
;
6432 output
= error_mark_node
;
6434 TREE_VALUE (tail
) = output
;
6437 /* Perform default conversions on array and function inputs.
6438 Don't do this for other types as it would screw up operands
6439 expected to be in memory. */
6440 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
6444 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
6445 input
= TREE_VALUE (tail
);
6447 input
= default_function_array_conversion (input
);
6449 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
6450 oconstraints
, &allows_mem
, &allows_reg
))
6452 /* If the operand is going to end up in memory,
6453 mark it addressable. */
6454 if (!allows_reg
&& allows_mem
)
6456 /* Strip the nops as we allow this case. FIXME, this really
6457 should be rejected or made deprecated. */
6459 if (!c_mark_addressable (input
))
6460 input
= error_mark_node
;
6464 input
= error_mark_node
;
6466 TREE_VALUE (tail
) = input
;
6469 args
= build_stmt (ASM_EXPR
, string
, outputs
, inputs
, clobbers
);
6471 /* Simple asm statements are treated as volatile. */
6474 ASM_VOLATILE_P (args
) = 1;
6475 ASM_INPUT_P (args
) = 1;
6481 /* Generate a goto statement to LABEL. */
6484 c_finish_goto_label (tree label
)
6486 tree decl
= lookup_label (label
);
6490 TREE_USED (decl
) = 1;
6491 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, decl
));
6494 /* Generate a computed goto statement to EXPR. */
6497 c_finish_goto_ptr (tree expr
)
6500 pedwarn ("ISO C forbids %<goto *expr;%>");
6501 expr
= convert (ptr_type_node
, expr
);
6502 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, expr
));
6505 /* Generate a C `return' statement. RETVAL is the expression for what
6506 to return, or a null pointer for `return;' with no value. */
6509 c_finish_return (tree retval
)
6511 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
6513 if (TREE_THIS_VOLATILE (current_function_decl
))
6514 warning ("function declared %<noreturn%> has a %<return%> statement");
6518 current_function_returns_null
= 1;
6519 if ((warn_return_type
|| flag_isoc99
)
6520 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
6521 pedwarn_c99 ("%<return%> with no value, in "
6522 "function returning non-void");
6524 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
6526 current_function_returns_null
= 1;
6527 if (pedantic
|| TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
6528 pedwarn ("%<return%> with a value, in function returning void");
6532 tree t
= convert_for_assignment (valtype
, retval
, ic_return
,
6533 NULL_TREE
, NULL_TREE
, 0);
6534 tree res
= DECL_RESULT (current_function_decl
);
6537 current_function_returns_value
= 1;
6538 if (t
== error_mark_node
)
6541 inner
= t
= convert (TREE_TYPE (res
), t
);
6543 /* Strip any conversions, additions, and subtractions, and see if
6544 we are returning the address of a local variable. Warn if so. */
6547 switch (TREE_CODE (inner
))
6549 case NOP_EXPR
: case NON_LVALUE_EXPR
: case CONVERT_EXPR
:
6551 inner
= TREE_OPERAND (inner
, 0);
6555 /* If the second operand of the MINUS_EXPR has a pointer
6556 type (or is converted from it), this may be valid, so
6557 don't give a warning. */
6559 tree op1
= TREE_OPERAND (inner
, 1);
6561 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
6562 && (TREE_CODE (op1
) == NOP_EXPR
6563 || TREE_CODE (op1
) == NON_LVALUE_EXPR
6564 || TREE_CODE (op1
) == CONVERT_EXPR
))
6565 op1
= TREE_OPERAND (op1
, 0);
6567 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
6570 inner
= TREE_OPERAND (inner
, 0);
6575 inner
= TREE_OPERAND (inner
, 0);
6577 while (REFERENCE_CLASS_P (inner
)
6578 && TREE_CODE (inner
) != INDIRECT_REF
)
6579 inner
= TREE_OPERAND (inner
, 0);
6582 && !DECL_EXTERNAL (inner
)
6583 && !TREE_STATIC (inner
)
6584 && DECL_CONTEXT (inner
) == current_function_decl
)
6585 warning ("function returns address of local variable");
6595 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
6598 return add_stmt (build_stmt (RETURN_EXPR
, retval
));
6602 /* The SWITCH_STMT being built. */
6605 /* The original type of the testing expression, i.e. before the
6606 default conversion is applied. */
6609 /* A splay-tree mapping the low element of a case range to the high
6610 element, or NULL_TREE if there is no high element. Used to
6611 determine whether or not a new case label duplicates an old case
6612 label. We need a tree, rather than simply a hash table, because
6613 of the GNU case range extension. */
6616 /* The next node on the stack. */
6617 struct c_switch
*next
;
6620 /* A stack of the currently active switch statements. The innermost
6621 switch statement is on the top of the stack. There is no need to
6622 mark the stack for garbage collection because it is only active
6623 during the processing of the body of a function, and we never
6624 collect at that point. */
6626 struct c_switch
*c_switch_stack
;
6628 /* Start a C switch statement, testing expression EXP. Return the new
6632 c_start_case (tree exp
)
6634 enum tree_code code
;
6635 tree type
, orig_type
= error_mark_node
;
6636 struct c_switch
*cs
;
6638 if (exp
!= error_mark_node
)
6640 code
= TREE_CODE (TREE_TYPE (exp
));
6641 orig_type
= TREE_TYPE (exp
);
6643 if (!INTEGRAL_TYPE_P (orig_type
)
6644 && code
!= ERROR_MARK
)
6646 error ("switch quantity not an integer");
6647 exp
= integer_zero_node
;
6648 orig_type
= error_mark_node
;
6652 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
6654 if (warn_traditional
&& !in_system_header
6655 && (type
== long_integer_type_node
6656 || type
== long_unsigned_type_node
))
6657 warning ("%<long%> switch expression not converted to "
6658 "%<int%> in ISO C");
6660 exp
= default_conversion (exp
);
6661 type
= TREE_TYPE (exp
);
6665 /* Add this new SWITCH_STMT to the stack. */
6666 cs
= XNEW (struct c_switch
);
6667 cs
->switch_stmt
= build_stmt (SWITCH_STMT
, exp
, NULL_TREE
, orig_type
);
6668 cs
->orig_type
= orig_type
;
6669 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
6670 cs
->next
= c_switch_stack
;
6671 c_switch_stack
= cs
;
6673 return add_stmt (cs
->switch_stmt
);
6676 /* Process a case label. */
6679 do_case (tree low_value
, tree high_value
)
6681 tree label
= NULL_TREE
;
6685 label
= c_add_case_label (c_switch_stack
->cases
,
6686 SWITCH_STMT_COND (c_switch_stack
->switch_stmt
),
6687 c_switch_stack
->orig_type
,
6688 low_value
, high_value
);
6689 if (label
== error_mark_node
)
6693 error ("case label not within a switch statement");
6695 error ("%<default%> label not within a switch statement");
6700 /* Finish the switch statement. */
6703 c_finish_case (tree body
)
6705 struct c_switch
*cs
= c_switch_stack
;
6707 SWITCH_STMT_BODY (cs
->switch_stmt
) = body
;
6709 /* Emit warnings as needed. */
6710 c_do_switch_warnings (cs
->cases
, cs
->switch_stmt
);
6712 /* Pop the stack. */
6713 c_switch_stack
= cs
->next
;
6714 splay_tree_delete (cs
->cases
);
6718 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
6719 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6720 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
6721 statement, and was not surrounded with parenthesis. */
6724 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
6725 tree else_block
, bool nested_if
)
6729 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
6730 if (warn_parentheses
&& nested_if
&& else_block
== NULL
)
6732 tree inner_if
= then_block
;
6734 /* We know from the grammar productions that there is an IF nested
6735 within THEN_BLOCK. Due to labels and c99 conditional declarations,
6736 it might not be exactly THEN_BLOCK, but should be the last
6737 non-container statement within. */
6739 switch (TREE_CODE (inner_if
))
6744 inner_if
= BIND_EXPR_BODY (inner_if
);
6746 case STATEMENT_LIST
:
6747 inner_if
= expr_last (then_block
);
6749 case TRY_FINALLY_EXPR
:
6750 case TRY_CATCH_EXPR
:
6751 inner_if
= TREE_OPERAND (inner_if
, 0);
6758 if (COND_EXPR_ELSE (inner_if
))
6759 warning ("%Hsuggest explicit braces to avoid ambiguous %<else%>",
6763 /* Diagnose ";" via the special empty statement node that we create. */
6766 if (TREE_CODE (then_block
) == NOP_EXPR
&& !TREE_TYPE (then_block
))
6769 warning ("%Hempty body in an if-statement",
6770 EXPR_LOCUS (then_block
));
6771 then_block
= alloc_stmt_list ();
6774 && TREE_CODE (else_block
) == NOP_EXPR
6775 && !TREE_TYPE (else_block
))
6777 warning ("%Hempty body in an else-statement",
6778 EXPR_LOCUS (else_block
));
6779 else_block
= alloc_stmt_list ();
6783 stmt
= build3 (COND_EXPR
, NULL_TREE
, cond
, then_block
, else_block
);
6784 SET_EXPR_LOCATION (stmt
, if_locus
);
6788 /* Emit a general-purpose loop construct. START_LOCUS is the location of
6789 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
6790 is false for DO loops. INCR is the FOR increment expression. BODY is
6791 the statement controlled by the loop. BLAB is the break label. CLAB is
6792 the continue label. Everything is allowed to be NULL. */
6795 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
6796 tree blab
, tree clab
, bool cond_is_first
)
6798 tree entry
= NULL
, exit
= NULL
, t
;
6800 /* If the condition is zero don't generate a loop construct. */
6801 if (cond
&& integer_zerop (cond
))
6805 t
= build_and_jump (&blab
);
6806 SET_EXPR_LOCATION (t
, start_locus
);
6812 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
6814 /* If we have an exit condition, then we build an IF with gotos either
6815 out of the loop, or to the top of it. If there's no exit condition,
6816 then we just build a jump back to the top. */
6817 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
6819 if (cond
&& !integer_nonzerop (cond
))
6821 /* Canonicalize the loop condition to the end. This means
6822 generating a branch to the loop condition. Reuse the
6823 continue label, if possible. */
6828 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
6829 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
6832 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
6833 SET_EXPR_LOCATION (t
, start_locus
);
6837 t
= build_and_jump (&blab
);
6838 exit
= build3 (COND_EXPR
, void_type_node
, cond
, exit
, t
);
6841 SET_EXPR_LOCATION (exit
, start_locus
);
6843 SET_EXPR_LOCATION (exit
, input_location
);
6852 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
6860 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
6864 c_finish_bc_stmt (tree
*label_p
, bool is_break
)
6867 tree label
= *label_p
;
6869 /* In switch statements break is sometimes stylistically used after
6870 a return statement. This can lead to spurious warnings about
6871 control reaching the end of a non-void function when it is
6872 inlined. Note that we are calling block_may_fallthru with
6873 language specific tree nodes; this works because
6874 block_may_fallthru returns true when given something it does not
6876 skip
= !block_may_fallthru (cur_stmt_list
);
6881 *label_p
= label
= create_artificial_label ();
6883 else if (TREE_CODE (label
) != LABEL_DECL
)
6886 error ("break statement not within loop or switch");
6888 error ("continue statement not within a loop");
6895 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
6898 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
6901 emit_side_effect_warnings (tree expr
)
6903 if (expr
== error_mark_node
)
6905 else if (!TREE_SIDE_EFFECTS (expr
))
6907 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
6908 warning ("%Hstatement with no effect",
6909 EXPR_HAS_LOCATION (expr
) ? EXPR_LOCUS (expr
) : &input_location
);
6911 else if (warn_unused_value
)
6912 warn_if_unused_value (expr
, input_location
);
6915 /* Process an expression as if it were a complete statement. Emit
6916 diagnostics, but do not call ADD_STMT. */
6919 c_process_expr_stmt (tree expr
)
6924 /* Do default conversion if safe and possibly important,
6925 in case within ({...}). */
6926 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
6927 && (flag_isoc99
|| lvalue_p (expr
)))
6928 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
6929 expr
= default_conversion (expr
);
6931 if (warn_sequence_point
)
6932 verify_sequence_points (expr
);
6934 if (TREE_TYPE (expr
) != error_mark_node
6935 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
6936 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
6937 error ("expression statement has incomplete type");
6939 /* If we're not processing a statement expression, warn about unused values.
6940 Warnings for statement expressions will be emitted later, once we figure
6941 out which is the result. */
6942 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
6943 && (extra_warnings
|| warn_unused_value
))
6944 emit_side_effect_warnings (expr
);
6946 /* If the expression is not of a type to which we cannot assign a line
6947 number, wrap the thing in a no-op NOP_EXPR. */
6948 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
6949 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
6952 SET_EXPR_LOCATION (expr
, input_location
);
6957 /* Emit an expression as a statement. */
6960 c_finish_expr_stmt (tree expr
)
6963 return add_stmt (c_process_expr_stmt (expr
));
6968 /* Do the opposite and emit a statement as an expression. To begin,
6969 create a new binding level and return it. */
6972 c_begin_stmt_expr (void)
6976 /* We must force a BLOCK for this level so that, if it is not expanded
6977 later, there is a way to turn off the entire subtree of blocks that
6978 are contained in it. */
6980 ret
= c_begin_compound_stmt (true);
6982 /* Mark the current statement list as belonging to a statement list. */
6983 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
6989 c_finish_stmt_expr (tree body
)
6991 tree last
, type
, tmp
, val
;
6994 body
= c_end_compound_stmt (body
, true);
6996 /* Locate the last statement in BODY. See c_end_compound_stmt
6997 about always returning a BIND_EXPR. */
6998 last_p
= &BIND_EXPR_BODY (body
);
6999 last
= BIND_EXPR_BODY (body
);
7002 if (TREE_CODE (last
) == STATEMENT_LIST
)
7004 tree_stmt_iterator i
;
7006 /* This can happen with degenerate cases like ({ }). No value. */
7007 if (!TREE_SIDE_EFFECTS (last
))
7010 /* If we're supposed to generate side effects warnings, process
7011 all of the statements except the last. */
7012 if (extra_warnings
|| warn_unused_value
)
7014 for (i
= tsi_start (last
); !tsi_one_before_end_p (i
); tsi_next (&i
))
7015 emit_side_effect_warnings (tsi_stmt (i
));
7018 i
= tsi_last (last
);
7019 last_p
= tsi_stmt_ptr (i
);
7023 /* If the end of the list is exception related, then the list was split
7024 by a call to push_cleanup. Continue searching. */
7025 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
7026 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
7028 last_p
= &TREE_OPERAND (last
, 0);
7030 goto continue_searching
;
7033 /* In the case that the BIND_EXPR is not necessary, return the
7034 expression out from inside it. */
7035 if (last
== error_mark_node
7036 || (last
== BIND_EXPR_BODY (body
)
7037 && BIND_EXPR_VARS (body
) == NULL
))
7040 /* Extract the type of said expression. */
7041 type
= TREE_TYPE (last
);
7043 /* If we're not returning a value at all, then the BIND_EXPR that
7044 we already have is a fine expression to return. */
7045 if (!type
|| VOID_TYPE_P (type
))
7048 /* Now that we've located the expression containing the value, it seems
7049 silly to make voidify_wrapper_expr repeat the process. Create a
7050 temporary of the appropriate type and stick it in a TARGET_EXPR. */
7051 tmp
= create_tmp_var_raw (type
, NULL
);
7053 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
7054 tree_expr_nonnegative_p giving up immediately. */
7056 if (TREE_CODE (val
) == NOP_EXPR
7057 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
7058 val
= TREE_OPERAND (val
, 0);
7060 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
7061 SET_EXPR_LOCUS (*last_p
, EXPR_LOCUS (last
));
7063 return build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
7066 /* Begin and end compound statements. This is as simple as pushing
7067 and popping new statement lists from the tree. */
7070 c_begin_compound_stmt (bool do_scope
)
7072 tree stmt
= push_stmt_list ();
7079 c_end_compound_stmt (tree stmt
, bool do_scope
)
7085 if (c_dialect_objc ())
7086 objc_clear_super_receiver ();
7087 block
= pop_scope ();
7090 stmt
= pop_stmt_list (stmt
);
7091 stmt
= c_build_bind_expr (block
, stmt
);
7093 /* If this compound statement is nested immediately inside a statement
7094 expression, then force a BIND_EXPR to be created. Otherwise we'll
7095 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
7096 STATEMENT_LISTs merge, and thus we can lose track of what statement
7099 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
7100 && TREE_CODE (stmt
) != BIND_EXPR
)
7102 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
7103 TREE_SIDE_EFFECTS (stmt
) = 1;
7109 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
7110 when the current scope is exited. EH_ONLY is true when this is not
7111 meant to apply to normal control flow transfer. */
7114 push_cleanup (tree
ARG_UNUSED (decl
), tree cleanup
, bool eh_only
)
7116 enum tree_code code
;
7120 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
7121 stmt
= build_stmt (code
, NULL
, cleanup
);
7123 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
7124 list
= push_stmt_list ();
7125 TREE_OPERAND (stmt
, 0) = list
;
7126 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
7129 /* Build a binary-operation expression without default conversions.
7130 CODE is the kind of expression to build.
7131 This function differs from `build' in several ways:
7132 the data type of the result is computed and recorded in it,
7133 warnings are generated if arg data types are invalid,
7134 special handling for addition and subtraction of pointers is known,
7135 and some optimization is done (operations on narrow ints
7136 are done in the narrower type when that gives the same result).
7137 Constant folding is also done before the result is returned.
7139 Note that the operands will never have enumeral types, or function
7140 or array types, because either they will have the default conversions
7141 performed or they have both just been converted to some other type in which
7142 the arithmetic is to be done. */
7145 build_binary_op (enum tree_code code
, tree orig_op0
, tree orig_op1
,
7149 enum tree_code code0
, code1
;
7152 /* Expression code to give to the expression when it is built.
7153 Normally this is CODE, which is what the caller asked for,
7154 but in some special cases we change it. */
7155 enum tree_code resultcode
= code
;
7157 /* Data type in which the computation is to be performed.
7158 In the simplest cases this is the common type of the arguments. */
7159 tree result_type
= NULL
;
7161 /* Nonzero means operands have already been type-converted
7162 in whatever way is necessary.
7163 Zero means they need to be converted to RESULT_TYPE. */
7166 /* Nonzero means create the expression with this type, rather than
7168 tree build_type
= 0;
7170 /* Nonzero means after finally constructing the expression
7171 convert it to this type. */
7172 tree final_type
= 0;
7174 /* Nonzero if this is an operation like MIN or MAX which can
7175 safely be computed in short if both args are promoted shorts.
7176 Also implies COMMON.
7177 -1 indicates a bitwise operation; this makes a difference
7178 in the exact conditions for when it is safe to do the operation
7179 in a narrower mode. */
7182 /* Nonzero if this is a comparison operation;
7183 if both args are promoted shorts, compare the original shorts.
7184 Also implies COMMON. */
7185 int short_compare
= 0;
7187 /* Nonzero if this is a right-shift operation, which can be computed on the
7188 original short and then promoted if the operand is a promoted short. */
7189 int short_shift
= 0;
7191 /* Nonzero means set RESULT_TYPE to the common type of the args. */
7196 op0
= default_conversion (orig_op0
);
7197 op1
= default_conversion (orig_op1
);
7205 type0
= TREE_TYPE (op0
);
7206 type1
= TREE_TYPE (op1
);
7208 /* The expression codes of the data types of the arguments tell us
7209 whether the arguments are integers, floating, pointers, etc. */
7210 code0
= TREE_CODE (type0
);
7211 code1
= TREE_CODE (type1
);
7213 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
7214 STRIP_TYPE_NOPS (op0
);
7215 STRIP_TYPE_NOPS (op1
);
7217 /* If an error was already reported for one of the arguments,
7218 avoid reporting another error. */
7220 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
7221 return error_mark_node
;
7226 /* Handle the pointer + int case. */
7227 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7228 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
7229 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
7230 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
7236 /* Subtraction of two similar pointers.
7237 We must subtract them as integers, then divide by object size. */
7238 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
7239 && comp_target_types (type0
, type1
, 1))
7240 return pointer_diff (op0
, op1
);
7241 /* Handle pointer minus int. Just like pointer plus int. */
7242 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7243 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
7252 case TRUNC_DIV_EXPR
:
7254 case FLOOR_DIV_EXPR
:
7255 case ROUND_DIV_EXPR
:
7256 case EXACT_DIV_EXPR
:
7257 /* Floating point division by zero is a legitimate way to obtain
7258 infinities and NaNs. */
7259 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
7260 warning ("division by zero");
7262 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
7263 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
7264 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
7265 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
7267 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
7268 code0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
7269 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
7270 code1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
7272 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
7273 resultcode
= RDIV_EXPR
;
7275 /* Although it would be tempting to shorten always here, that
7276 loses on some targets, since the modulo instruction is
7277 undefined if the quotient can't be represented in the
7278 computation mode. We shorten only if unsigned or if
7279 dividing by something we know != -1. */
7280 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
7281 || (TREE_CODE (op1
) == INTEGER_CST
7282 && !integer_all_onesp (op1
)));
7290 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7292 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
7296 case TRUNC_MOD_EXPR
:
7297 case FLOOR_MOD_EXPR
:
7298 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
7299 warning ("division by zero");
7301 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7303 /* Although it would be tempting to shorten always here, that loses
7304 on some targets, since the modulo instruction is undefined if the
7305 quotient can't be represented in the computation mode. We shorten
7306 only if unsigned or if dividing by something we know != -1. */
7307 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
7308 || (TREE_CODE (op1
) == INTEGER_CST
7309 && !integer_all_onesp (op1
)));
7314 case TRUTH_ANDIF_EXPR
:
7315 case TRUTH_ORIF_EXPR
:
7316 case TRUTH_AND_EXPR
:
7318 case TRUTH_XOR_EXPR
:
7319 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
7320 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
7321 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
7322 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
7324 /* Result of these operations is always an int,
7325 but that does not mean the operands should be
7326 converted to ints! */
7327 result_type
= integer_type_node
;
7328 op0
= lang_hooks
.truthvalue_conversion (op0
);
7329 op1
= lang_hooks
.truthvalue_conversion (op1
);
7334 /* Shift operations: result has same type as first operand;
7335 always convert second operand to int.
7336 Also set SHORT_SHIFT if shifting rightward. */
7339 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7341 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
7343 if (tree_int_cst_sgn (op1
) < 0)
7344 warning ("right shift count is negative");
7347 if (!integer_zerop (op1
))
7350 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
7351 warning ("right shift count >= width of type");
7355 /* Use the type of the value to be shifted. */
7356 result_type
= type0
;
7357 /* Convert the shift-count to an integer, regardless of size
7358 of value being shifted. */
7359 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
7360 op1
= convert (integer_type_node
, op1
);
7361 /* Avoid converting op1 to result_type later. */
7367 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
7369 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
7371 if (tree_int_cst_sgn (op1
) < 0)
7372 warning ("left shift count is negative");
7374 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
7375 warning ("left shift count >= width of type");
7378 /* Use the type of the value to be shifted. */
7379 result_type
= type0
;
7380 /* Convert the shift-count to an integer, regardless of size
7381 of value being shifted. */
7382 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
7383 op1
= convert (integer_type_node
, op1
);
7384 /* Avoid converting op1 to result_type later. */
7391 if (warn_float_equal
&& (code0
== REAL_TYPE
|| code1
== REAL_TYPE
))
7392 warning ("comparing floating point with == or != is unsafe");
7393 /* Result of comparison is always int,
7394 but don't convert the args to int! */
7395 build_type
= integer_type_node
;
7396 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
7397 || code0
== COMPLEX_TYPE
)
7398 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
7399 || code1
== COMPLEX_TYPE
))
7401 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
7403 tree tt0
= TREE_TYPE (type0
);
7404 tree tt1
= TREE_TYPE (type1
);
7405 /* Anything compares with void *. void * compares with anything.
7406 Otherwise, the targets must be compatible
7407 and both must be object or both incomplete. */
7408 if (comp_target_types (type0
, type1
, 1))
7409 result_type
= common_pointer_type (type0
, type1
);
7410 else if (VOID_TYPE_P (tt0
))
7412 /* op0 != orig_op0 detects the case of something
7413 whose value is 0 but which isn't a valid null ptr const. */
7414 if (pedantic
&& (!integer_zerop (op0
) || op0
!= orig_op0
)
7415 && TREE_CODE (tt1
) == FUNCTION_TYPE
)
7416 pedwarn ("ISO C forbids comparison of %<void *%>"
7417 " with function pointer");
7419 else if (VOID_TYPE_P (tt1
))
7421 if (pedantic
&& (!integer_zerop (op1
) || op1
!= orig_op1
)
7422 && TREE_CODE (tt0
) == FUNCTION_TYPE
)
7423 pedwarn ("ISO C forbids comparison of %<void *%>"
7424 " with function pointer");
7427 pedwarn ("comparison of distinct pointer types lacks a cast");
7429 if (result_type
== NULL_TREE
)
7430 result_type
= ptr_type_node
;
7432 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
7433 && integer_zerop (op1
))
7434 result_type
= type0
;
7435 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
7436 && integer_zerop (op0
))
7437 result_type
= type1
;
7438 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7440 result_type
= type0
;
7441 pedwarn ("comparison between pointer and integer");
7443 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
7445 result_type
= type1
;
7446 pedwarn ("comparison between pointer and integer");
7454 build_type
= integer_type_node
;
7455 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
7456 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
7458 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
7460 if (comp_target_types (type0
, type1
, 1))
7462 result_type
= common_pointer_type (type0
, type1
);
7463 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
7464 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
7465 pedwarn ("comparison of complete and incomplete pointers");
7467 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
7468 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7472 result_type
= ptr_type_node
;
7473 pedwarn ("comparison of distinct pointer types lacks a cast");
7476 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
7477 && integer_zerop (op1
))
7479 result_type
= type0
;
7480 if (pedantic
|| extra_warnings
)
7481 pedwarn ("ordered comparison of pointer with integer zero");
7483 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
7484 && integer_zerop (op0
))
7486 result_type
= type1
;
7488 pedwarn ("ordered comparison of pointer with integer zero");
7490 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
7492 result_type
= type0
;
7493 pedwarn ("comparison between pointer and integer");
7495 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
7497 result_type
= type1
;
7498 pedwarn ("comparison between pointer and integer");
7506 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
7507 return error_mark_node
;
7509 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
7510 || code0
== VECTOR_TYPE
)
7512 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
7513 || code1
== VECTOR_TYPE
))
7515 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
7517 if (shorten
|| common
|| short_compare
)
7518 result_type
= c_common_type (type0
, type1
);
7520 /* For certain operations (which identify themselves by shorten != 0)
7521 if both args were extended from the same smaller type,
7522 do the arithmetic in that type and then extend.
7524 shorten !=0 and !=1 indicates a bitwise operation.
7525 For them, this optimization is safe only if
7526 both args are zero-extended or both are sign-extended.
7527 Otherwise, we might change the result.
7528 Eg, (short)-1 | (unsigned short)-1 is (int)-1
7529 but calculated in (unsigned short) it would be (unsigned short)-1. */
7531 if (shorten
&& none_complex
)
7533 int unsigned0
, unsigned1
;
7534 tree arg0
= get_narrower (op0
, &unsigned0
);
7535 tree arg1
= get_narrower (op1
, &unsigned1
);
7536 /* UNS is 1 if the operation to be done is an unsigned one. */
7537 int uns
= TYPE_UNSIGNED (result_type
);
7540 final_type
= result_type
;
7542 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7543 but it *requires* conversion to FINAL_TYPE. */
7545 if ((TYPE_PRECISION (TREE_TYPE (op0
))
7546 == TYPE_PRECISION (TREE_TYPE (arg0
)))
7547 && TREE_TYPE (op0
) != final_type
)
7548 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
7549 if ((TYPE_PRECISION (TREE_TYPE (op1
))
7550 == TYPE_PRECISION (TREE_TYPE (arg1
)))
7551 && TREE_TYPE (op1
) != final_type
)
7552 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
7554 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
7556 /* For bitwise operations, signedness of nominal type
7557 does not matter. Consider only how operands were extended. */
7561 /* Note that in all three cases below we refrain from optimizing
7562 an unsigned operation on sign-extended args.
7563 That would not be valid. */
7565 /* Both args variable: if both extended in same way
7566 from same width, do it in that width.
7567 Do it unsigned if args were zero-extended. */
7568 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
7569 < TYPE_PRECISION (result_type
))
7570 && (TYPE_PRECISION (TREE_TYPE (arg1
))
7571 == TYPE_PRECISION (TREE_TYPE (arg0
)))
7572 && unsigned0
== unsigned1
7573 && (unsigned0
|| !uns
))
7575 = c_common_signed_or_unsigned_type
7576 (unsigned0
, c_common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
7577 else if (TREE_CODE (arg0
) == INTEGER_CST
7578 && (unsigned1
|| !uns
)
7579 && (TYPE_PRECISION (TREE_TYPE (arg1
))
7580 < TYPE_PRECISION (result_type
))
7582 = c_common_signed_or_unsigned_type (unsigned1
,
7584 int_fits_type_p (arg0
, type
)))
7586 else if (TREE_CODE (arg1
) == INTEGER_CST
7587 && (unsigned0
|| !uns
)
7588 && (TYPE_PRECISION (TREE_TYPE (arg0
))
7589 < TYPE_PRECISION (result_type
))
7591 = c_common_signed_or_unsigned_type (unsigned0
,
7593 int_fits_type_p (arg1
, type
)))
7597 /* Shifts can be shortened if shifting right. */
7602 tree arg0
= get_narrower (op0
, &unsigned_arg
);
7604 final_type
= result_type
;
7606 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
7607 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
7609 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
7610 /* We can shorten only if the shift count is less than the
7611 number of bits in the smaller type size. */
7612 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
7613 /* We cannot drop an unsigned shift after sign-extension. */
7614 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
7616 /* Do an unsigned shift if the operand was zero-extended. */
7618 = c_common_signed_or_unsigned_type (unsigned_arg
,
7620 /* Convert value-to-be-shifted to that type. */
7621 if (TREE_TYPE (op0
) != result_type
)
7622 op0
= convert (result_type
, op0
);
7627 /* Comparison operations are shortened too but differently.
7628 They identify themselves by setting short_compare = 1. */
7632 /* Don't write &op0, etc., because that would prevent op0
7633 from being kept in a register.
7634 Instead, make copies of the our local variables and
7635 pass the copies by reference, then copy them back afterward. */
7636 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
7637 enum tree_code xresultcode
= resultcode
;
7639 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
7644 op0
= xop0
, op1
= xop1
;
7646 resultcode
= xresultcode
;
7648 if (warn_sign_compare
&& skip_evaluation
== 0)
7650 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
7651 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
7652 int unsignedp0
, unsignedp1
;
7653 tree primop0
= get_narrower (op0
, &unsignedp0
);
7654 tree primop1
= get_narrower (op1
, &unsignedp1
);
7658 STRIP_TYPE_NOPS (xop0
);
7659 STRIP_TYPE_NOPS (xop1
);
7661 /* Give warnings for comparisons between signed and unsigned
7662 quantities that may fail.
7664 Do the checking based on the original operand trees, so that
7665 casts will be considered, but default promotions won't be.
7667 Do not warn if the comparison is being done in a signed type,
7668 since the signed type will only be chosen if it can represent
7669 all the values of the unsigned type. */
7670 if (!TYPE_UNSIGNED (result_type
))
7672 /* Do not warn if both operands are the same signedness. */
7673 else if (op0_signed
== op1_signed
)
7680 sop
= xop0
, uop
= xop1
;
7682 sop
= xop1
, uop
= xop0
;
7684 /* Do not warn if the signed quantity is an
7685 unsuffixed integer literal (or some static
7686 constant expression involving such literals or a
7687 conditional expression involving such literals)
7688 and it is non-negative. */
7689 if (tree_expr_nonnegative_p (sop
))
7691 /* Do not warn if the comparison is an equality operation,
7692 the unsigned quantity is an integral constant, and it
7693 would fit in the result if the result were signed. */
7694 else if (TREE_CODE (uop
) == INTEGER_CST
7695 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
7697 (uop
, c_common_signed_type (result_type
)))
7699 /* Do not warn if the unsigned quantity is an enumeration
7700 constant and its maximum value would fit in the result
7701 if the result were signed. */
7702 else if (TREE_CODE (uop
) == INTEGER_CST
7703 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
7705 (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
7706 c_common_signed_type (result_type
)))
7709 warning ("comparison between signed and unsigned");
7712 /* Warn if two unsigned values are being compared in a size
7713 larger than their original size, and one (and only one) is the
7714 result of a `~' operator. This comparison will always fail.
7716 Also warn if one operand is a constant, and the constant
7717 does not have all bits set that are set in the ~ operand
7718 when it is extended. */
7720 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
7721 != (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
7723 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
7724 primop0
= get_narrower (TREE_OPERAND (primop0
, 0),
7727 primop1
= get_narrower (TREE_OPERAND (primop1
, 0),
7730 if (host_integerp (primop0
, 0) || host_integerp (primop1
, 0))
7733 HOST_WIDE_INT constant
, mask
;
7734 int unsignedp
, bits
;
7736 if (host_integerp (primop0
, 0))
7739 unsignedp
= unsignedp1
;
7740 constant
= tree_low_cst (primop0
, 0);
7745 unsignedp
= unsignedp0
;
7746 constant
= tree_low_cst (primop1
, 0);
7749 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
7750 if (bits
< TYPE_PRECISION (result_type
)
7751 && bits
< HOST_BITS_PER_WIDE_INT
&& unsignedp
)
7753 mask
= (~(HOST_WIDE_INT
) 0) << bits
;
7754 if ((mask
& constant
) != mask
)
7755 warning ("comparison of promoted ~unsigned with constant");
7758 else if (unsignedp0
&& unsignedp1
7759 && (TYPE_PRECISION (TREE_TYPE (primop0
))
7760 < TYPE_PRECISION (result_type
))
7761 && (TYPE_PRECISION (TREE_TYPE (primop1
))
7762 < TYPE_PRECISION (result_type
)))
7763 warning ("comparison of promoted ~unsigned with unsigned");
7769 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7770 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7771 Then the expression will be built.
7772 It will be given type FINAL_TYPE if that is nonzero;
7773 otherwise, it will be given type RESULT_TYPE. */
7777 binary_op_error (code
);
7778 return error_mark_node
;
7783 if (TREE_TYPE (op0
) != result_type
)
7784 op0
= convert (result_type
, op0
);
7785 if (TREE_TYPE (op1
) != result_type
)
7786 op1
= convert (result_type
, op1
);
7788 /* This can happen if one operand has a vector type, and the other
7789 has a different type. */
7790 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
7791 return error_mark_node
;
7794 if (build_type
== NULL_TREE
)
7795 build_type
= result_type
;
7798 tree result
= build2 (resultcode
, build_type
, op0
, op1
);
7800 /* Treat expressions in initializers specially as they can't trap. */
7801 result
= require_constant_value
? fold_initializer (result
)
7804 if (final_type
!= 0)
7805 result
= convert (final_type
, result
);