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, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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"
33 #include "langhooks.h"
41 #include "tree-iterator.h"
42 #include "tree-flow.h"
44 /* Possible cases of implicit bad conversions. Used to select
45 diagnostic messages in convert_for_assignment. */
53 /* Whether we are building a boolean conversion inside
54 convert_for_assignment, or some other late binary operation. If
55 build_binary_op is called (from code shared with C++) in this case,
56 then the operands have already been folded and the result will not
57 be folded again, so C_MAYBE_CONST_EXPR should not be generated. */
58 bool in_late_binary_op
;
60 /* The level of nesting inside "__alignof__". */
63 /* The level of nesting inside "sizeof". */
66 /* The level of nesting inside "typeof". */
69 /* Nonzero if we've already printed a "missing braces around initializer"
70 message within this initializer. */
71 static int missing_braces_mentioned
;
73 static int require_constant_value
;
74 static int require_constant_elements
;
76 static bool null_pointer_constant_p (const_tree
);
77 static tree
qualify_type (tree
, tree
);
78 static int tagged_types_tu_compatible_p (const_tree
, const_tree
, bool *,
80 static int comp_target_types (location_t
, tree
, tree
);
81 static int function_types_compatible_p (const_tree
, const_tree
, bool *,
83 static int type_lists_compatible_p (const_tree
, const_tree
, bool *, bool *);
84 static tree
lookup_field (tree
, tree
);
85 static int convert_arguments (tree
, VEC(tree
,gc
) *, VEC(tree
,gc
) *, tree
,
87 static tree
pointer_diff (location_t
, tree
, tree
);
88 static tree
convert_for_assignment (location_t
, tree
, tree
, tree
,
89 enum impl_conv
, bool, tree
, tree
, int);
90 static tree
valid_compound_expr_initializer (tree
, tree
);
91 static void push_string (const char *);
92 static void push_member_name (tree
);
93 static int spelling_length (void);
94 static char *print_spelling (char *);
95 static void warning_init (int, const char *);
96 static tree
digest_init (location_t
, tree
, tree
, tree
, bool, bool, int);
97 static void output_init_element (tree
, tree
, bool, tree
, tree
, int, bool,
99 static void output_pending_init_elements (int, struct obstack
*);
100 static int set_designator (int, struct obstack
*);
101 static void push_range_stack (tree
, struct obstack
*);
102 static void add_pending_init (tree
, tree
, tree
, bool, struct obstack
*);
103 static void set_nonincremental_init (struct obstack
*);
104 static void set_nonincremental_init_from_string (tree
, struct obstack
*);
105 static tree
find_init_member (tree
, struct obstack
*);
106 static void readonly_error (tree
, enum lvalue_use
);
107 static void readonly_warning (tree
, enum lvalue_use
);
108 static int lvalue_or_else (const_tree
, enum lvalue_use
);
109 static void record_maybe_used_decl (tree
);
110 static int comptypes_internal (const_tree
, const_tree
, bool *, bool *);
112 /* Return true if EXP is a null pointer constant, false otherwise. */
115 null_pointer_constant_p (const_tree expr
)
117 /* This should really operate on c_expr structures, but they aren't
118 yet available everywhere required. */
119 tree type
= TREE_TYPE (expr
);
120 return (TREE_CODE (expr
) == INTEGER_CST
121 && !TREE_OVERFLOW (expr
)
122 && integer_zerop (expr
)
123 && (INTEGRAL_TYPE_P (type
)
124 || (TREE_CODE (type
) == POINTER_TYPE
125 && VOID_TYPE_P (TREE_TYPE (type
))
126 && TYPE_QUALS (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
)));
129 /* EXPR may appear in an unevaluated part of an integer constant
130 expression, but not in an evaluated part. Wrap it in a
131 C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
132 INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR. */
135 note_integer_operands (tree expr
)
138 if (TREE_CODE (expr
) == INTEGER_CST
&& in_late_binary_op
)
140 ret
= copy_node (expr
);
141 TREE_OVERFLOW (ret
) = 1;
145 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL_TREE
, expr
);
146 C_MAYBE_CONST_EXPR_INT_OPERANDS (ret
) = 1;
151 /* Having checked whether EXPR may appear in an unevaluated part of an
152 integer constant expression and found that it may, remove any
153 C_MAYBE_CONST_EXPR noting this fact and return the resulting
157 remove_c_maybe_const_expr (tree expr
)
159 if (TREE_CODE (expr
) == C_MAYBE_CONST_EXPR
)
160 return C_MAYBE_CONST_EXPR_EXPR (expr
);
165 \f/* This is a cache to hold if two types are compatible or not. */
167 struct tagged_tu_seen_cache
{
168 const struct tagged_tu_seen_cache
* next
;
171 /* The return value of tagged_types_tu_compatible_p if we had seen
172 these two types already. */
176 static const struct tagged_tu_seen_cache
* tagged_tu_seen_base
;
177 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache
*);
179 /* Do `exp = require_complete_type (exp);' to make sure exp
180 does not have an incomplete type. (That includes void types.) */
183 require_complete_type (tree value
)
185 tree type
= TREE_TYPE (value
);
187 if (value
== error_mark_node
|| type
== error_mark_node
)
188 return error_mark_node
;
190 /* First, detect a valid value with a complete type. */
191 if (COMPLETE_TYPE_P (type
))
194 c_incomplete_type_error (value
, type
);
195 return error_mark_node
;
198 /* Print an error message for invalid use of an incomplete type.
199 VALUE is the expression that was used (or 0 if that isn't known)
200 and TYPE is the type that was invalid. */
203 c_incomplete_type_error (const_tree value
, const_tree type
)
205 const char *type_code_string
;
207 /* Avoid duplicate error message. */
208 if (TREE_CODE (type
) == ERROR_MARK
)
211 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
212 || TREE_CODE (value
) == PARM_DECL
))
213 error ("%qD has an incomplete type", value
);
217 /* We must print an error message. Be clever about what it says. */
219 switch (TREE_CODE (type
))
222 type_code_string
= "struct";
226 type_code_string
= "union";
230 type_code_string
= "enum";
234 error ("invalid use of void expression");
238 if (TYPE_DOMAIN (type
))
240 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL
)
242 error ("invalid use of flexible array member");
245 type
= TREE_TYPE (type
);
248 error ("invalid use of array with unspecified bounds");
255 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
256 error ("invalid use of undefined type %<%s %E%>",
257 type_code_string
, TYPE_NAME (type
));
259 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
260 error ("invalid use of incomplete typedef %qD", TYPE_NAME (type
));
264 /* Given a type, apply default promotions wrt unnamed function
265 arguments and return the new type. */
268 c_type_promotes_to (tree type
)
270 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
271 return double_type_node
;
273 if (c_promoting_integer_type_p (type
))
275 /* Preserve unsignedness if not really getting any wider. */
276 if (TYPE_UNSIGNED (type
)
277 && (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
278 return unsigned_type_node
;
279 return integer_type_node
;
285 /* Return true if between two named address spaces, whether there is a superset
286 named address space that encompasses both address spaces. If there is a
287 superset, return which address space is the superset. */
290 addr_space_superset (addr_space_t as1
, addr_space_t as2
, addr_space_t
*common
)
297 else if (targetm
.addr_space
.subset_p (as1
, as2
))
302 else if (targetm
.addr_space
.subset_p (as2
, as1
))
311 /* Return a variant of TYPE which has all the type qualifiers of LIKE
312 as well as those of TYPE. */
315 qualify_type (tree type
, tree like
)
317 addr_space_t as_type
= TYPE_ADDR_SPACE (type
);
318 addr_space_t as_like
= TYPE_ADDR_SPACE (like
);
319 addr_space_t as_common
;
321 /* If the two named address spaces are different, determine the common
322 superset address space. If there isn't one, raise an error. */
323 if (!addr_space_superset (as_type
, as_like
, &as_common
))
326 error ("%qT and %qT are in disjoint named address spaces",
330 return c_build_qualified_type (type
,
331 TYPE_QUALS_NO_ADDR_SPACE (type
)
332 | TYPE_QUALS_NO_ADDR_SPACE (like
)
333 | ENCODE_QUAL_ADDR_SPACE (as_common
));
336 /* Return true iff the given tree T is a variable length array. */
339 c_vla_type_p (const_tree t
)
341 if (TREE_CODE (t
) == ARRAY_TYPE
342 && C_TYPE_VARIABLE_SIZE (t
))
347 /* Return the composite type of two compatible types.
349 We assume that comptypes has already been done and returned
350 nonzero; if that isn't so, this may crash. In particular, we
351 assume that qualifiers match. */
354 composite_type (tree t1
, tree t2
)
356 enum tree_code code1
;
357 enum tree_code code2
;
360 /* Save time if the two types are the same. */
362 if (t1
== t2
) return t1
;
364 /* If one type is nonsense, use the other. */
365 if (t1
== error_mark_node
)
367 if (t2
== error_mark_node
)
370 code1
= TREE_CODE (t1
);
371 code2
= TREE_CODE (t2
);
373 /* Merge the attributes. */
374 attributes
= targetm
.merge_type_attributes (t1
, t2
);
376 /* If one is an enumerated type and the other is the compatible
377 integer type, the composite type might be either of the two
378 (DR#013 question 3). For consistency, use the enumerated type as
379 the composite type. */
381 if (code1
== ENUMERAL_TYPE
&& code2
== INTEGER_TYPE
)
383 if (code2
== ENUMERAL_TYPE
&& code1
== INTEGER_TYPE
)
386 gcc_assert (code1
== code2
);
391 /* For two pointers, do this recursively on the target type. */
393 tree pointed_to_1
= TREE_TYPE (t1
);
394 tree pointed_to_2
= TREE_TYPE (t2
);
395 tree target
= composite_type (pointed_to_1
, pointed_to_2
);
396 t1
= build_pointer_type (target
);
397 t1
= build_type_attribute_variant (t1
, attributes
);
398 return qualify_type (t1
, t2
);
403 tree elt
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
406 tree d1
= TYPE_DOMAIN (t1
);
407 tree d2
= TYPE_DOMAIN (t2
);
408 bool d1_variable
, d2_variable
;
409 bool d1_zero
, d2_zero
;
410 bool t1_complete
, t2_complete
;
412 /* We should not have any type quals on arrays at all. */
413 gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1
)
414 && !TYPE_QUALS_NO_ADDR_SPACE (t2
));
416 t1_complete
= COMPLETE_TYPE_P (t1
);
417 t2_complete
= COMPLETE_TYPE_P (t2
);
419 d1_zero
= d1
== 0 || !TYPE_MAX_VALUE (d1
);
420 d2_zero
= d2
== 0 || !TYPE_MAX_VALUE (d2
);
422 d1_variable
= (!d1_zero
423 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
424 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
425 d2_variable
= (!d2_zero
426 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
427 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
428 d1_variable
= d1_variable
|| (d1_zero
&& c_vla_type_p (t1
));
429 d2_variable
= d2_variable
|| (d2_zero
&& c_vla_type_p (t2
));
431 /* Save space: see if the result is identical to one of the args. */
432 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
)
433 && (d2_variable
|| d2_zero
|| !d1_variable
))
434 return build_type_attribute_variant (t1
, attributes
);
435 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
)
436 && (d1_variable
|| d1_zero
|| !d2_variable
))
437 return build_type_attribute_variant (t2
, attributes
);
439 if (elt
== TREE_TYPE (t1
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
440 return build_type_attribute_variant (t1
, attributes
);
441 if (elt
== TREE_TYPE (t2
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
442 return build_type_attribute_variant (t2
, attributes
);
444 /* Merge the element types, and have a size if either arg has
445 one. We may have qualifiers on the element types. To set
446 up TYPE_MAIN_VARIANT correctly, we need to form the
447 composite of the unqualified types and add the qualifiers
449 quals
= TYPE_QUALS (strip_array_types (elt
));
450 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
451 t1
= build_array_type (unqual_elt
,
452 TYPE_DOMAIN ((TYPE_DOMAIN (t1
)
458 /* Ensure a composite type involving a zero-length array type
459 is a zero-length type not an incomplete type. */
460 if (d1_zero
&& d2_zero
461 && (t1_complete
|| t2_complete
)
462 && !COMPLETE_TYPE_P (t1
))
464 TYPE_SIZE (t1
) = bitsize_zero_node
;
465 TYPE_SIZE_UNIT (t1
) = size_zero_node
;
467 t1
= c_build_qualified_type (t1
, quals
);
468 return build_type_attribute_variant (t1
, attributes
);
474 if (attributes
!= NULL
)
476 /* Try harder not to create a new aggregate type. */
477 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
479 if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
482 return build_type_attribute_variant (t1
, attributes
);
485 /* Function types: prefer the one that specified arg types.
486 If both do, merge the arg types. Also merge the return types. */
488 tree valtype
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
489 tree p1
= TYPE_ARG_TYPES (t1
);
490 tree p2
= TYPE_ARG_TYPES (t2
);
495 /* Save space: see if the result is identical to one of the args. */
496 if (valtype
== TREE_TYPE (t1
) && !TYPE_ARG_TYPES (t2
))
497 return build_type_attribute_variant (t1
, attributes
);
498 if (valtype
== TREE_TYPE (t2
) && !TYPE_ARG_TYPES (t1
))
499 return build_type_attribute_variant (t2
, attributes
);
501 /* Simple way if one arg fails to specify argument types. */
502 if (TYPE_ARG_TYPES (t1
) == 0)
504 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t2
));
505 t1
= build_type_attribute_variant (t1
, attributes
);
506 return qualify_type (t1
, t2
);
508 if (TYPE_ARG_TYPES (t2
) == 0)
510 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t1
));
511 t1
= build_type_attribute_variant (t1
, attributes
);
512 return qualify_type (t1
, t2
);
515 /* If both args specify argument types, we must merge the two
516 lists, argument by argument. */
517 /* Tell global_bindings_p to return false so that variable_size
518 doesn't die on VLAs in parameter types. */
519 c_override_global_bindings_to_false
= true;
521 len
= list_length (p1
);
524 for (i
= 0; i
< len
; i
++)
525 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
530 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
))
532 /* A null type means arg type is not specified.
533 Take whatever the other function type has. */
534 if (TREE_VALUE (p1
) == 0)
536 TREE_VALUE (n
) = TREE_VALUE (p2
);
539 if (TREE_VALUE (p2
) == 0)
541 TREE_VALUE (n
) = TREE_VALUE (p1
);
545 /* Given wait (union {union wait *u; int *i} *)
546 and wait (union wait *),
547 prefer union wait * as type of parm. */
548 if (TREE_CODE (TREE_VALUE (p1
)) == UNION_TYPE
549 && TREE_VALUE (p1
) != TREE_VALUE (p2
))
552 tree mv2
= TREE_VALUE (p2
);
553 if (mv2
&& mv2
!= error_mark_node
554 && TREE_CODE (mv2
) != ARRAY_TYPE
)
555 mv2
= TYPE_MAIN_VARIANT (mv2
);
556 for (memb
= TYPE_FIELDS (TREE_VALUE (p1
));
557 memb
; memb
= TREE_CHAIN (memb
))
559 tree mv3
= TREE_TYPE (memb
);
560 if (mv3
&& mv3
!= error_mark_node
561 && TREE_CODE (mv3
) != ARRAY_TYPE
)
562 mv3
= TYPE_MAIN_VARIANT (mv3
);
563 if (comptypes (mv3
, mv2
))
565 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
567 pedwarn (input_location
, OPT_pedantic
,
568 "function types not truly compatible in ISO C");
573 if (TREE_CODE (TREE_VALUE (p2
)) == UNION_TYPE
574 && TREE_VALUE (p2
) != TREE_VALUE (p1
))
577 tree mv1
= TREE_VALUE (p1
);
578 if (mv1
&& mv1
!= error_mark_node
579 && TREE_CODE (mv1
) != ARRAY_TYPE
)
580 mv1
= TYPE_MAIN_VARIANT (mv1
);
581 for (memb
= TYPE_FIELDS (TREE_VALUE (p2
));
582 memb
; memb
= TREE_CHAIN (memb
))
584 tree mv3
= TREE_TYPE (memb
);
585 if (mv3
&& mv3
!= error_mark_node
586 && TREE_CODE (mv3
) != ARRAY_TYPE
)
587 mv3
= TYPE_MAIN_VARIANT (mv3
);
588 if (comptypes (mv3
, mv1
))
590 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
592 pedwarn (input_location
, OPT_pedantic
,
593 "function types not truly compatible in ISO C");
598 TREE_VALUE (n
) = composite_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
602 c_override_global_bindings_to_false
= false;
603 t1
= build_function_type (valtype
, newargs
);
604 t1
= qualify_type (t1
, t2
);
605 /* ... falls through ... */
609 return build_type_attribute_variant (t1
, attributes
);
614 /* Return the type of a conditional expression between pointers to
615 possibly differently qualified versions of compatible types.
617 We assume that comp_target_types has already been done and returned
618 nonzero; if that isn't so, this may crash. */
621 common_pointer_type (tree t1
, tree t2
)
624 tree pointed_to_1
, mv1
;
625 tree pointed_to_2
, mv2
;
627 unsigned target_quals
;
628 addr_space_t as1
, as2
, as_common
;
631 /* Save time if the two types are the same. */
633 if (t1
== t2
) return t1
;
635 /* If one type is nonsense, use the other. */
636 if (t1
== error_mark_node
)
638 if (t2
== error_mark_node
)
641 gcc_assert (TREE_CODE (t1
) == POINTER_TYPE
642 && TREE_CODE (t2
) == POINTER_TYPE
);
644 /* Merge the attributes. */
645 attributes
= targetm
.merge_type_attributes (t1
, t2
);
647 /* Find the composite type of the target types, and combine the
648 qualifiers of the two types' targets. Do not lose qualifiers on
649 array element types by taking the TYPE_MAIN_VARIANT. */
650 mv1
= pointed_to_1
= TREE_TYPE (t1
);
651 mv2
= pointed_to_2
= TREE_TYPE (t2
);
652 if (TREE_CODE (mv1
) != ARRAY_TYPE
)
653 mv1
= TYPE_MAIN_VARIANT (pointed_to_1
);
654 if (TREE_CODE (mv2
) != ARRAY_TYPE
)
655 mv2
= TYPE_MAIN_VARIANT (pointed_to_2
);
656 target
= composite_type (mv1
, mv2
);
658 /* For function types do not merge const qualifiers, but drop them
659 if used inconsistently. The middle-end uses these to mark const
660 and noreturn functions. */
661 quals1
= TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1
);
662 quals2
= TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2
);
664 if (TREE_CODE (pointed_to_1
) == FUNCTION_TYPE
)
665 target_quals
= (quals1
& quals2
);
667 target_quals
= (quals1
| quals2
);
669 /* If the two named address spaces are different, determine the common
670 superset address space. This is guaranteed to exist due to the
671 assumption that comp_target_type returned non-zero. */
672 as1
= TYPE_ADDR_SPACE (pointed_to_1
);
673 as2
= TYPE_ADDR_SPACE (pointed_to_2
);
674 if (!addr_space_superset (as1
, as2
, &as_common
))
677 target_quals
|= ENCODE_QUAL_ADDR_SPACE (as_common
);
679 t1
= build_pointer_type (c_build_qualified_type (target
, target_quals
));
680 return build_type_attribute_variant (t1
, attributes
);
683 /* Return the common type for two arithmetic types under the usual
684 arithmetic conversions. The default conversions have already been
685 applied, and enumerated types converted to their compatible integer
686 types. The resulting type is unqualified and has no attributes.
688 This is the type for the result of most arithmetic operations
689 if the operands have the given two types. */
692 c_common_type (tree t1
, tree t2
)
694 enum tree_code code1
;
695 enum tree_code code2
;
697 /* If one type is nonsense, use the other. */
698 if (t1
== error_mark_node
)
700 if (t2
== error_mark_node
)
703 if (TYPE_QUALS (t1
) != TYPE_UNQUALIFIED
)
704 t1
= TYPE_MAIN_VARIANT (t1
);
706 if (TYPE_QUALS (t2
) != TYPE_UNQUALIFIED
)
707 t2
= TYPE_MAIN_VARIANT (t2
);
709 if (TYPE_ATTRIBUTES (t1
) != NULL_TREE
)
710 t1
= build_type_attribute_variant (t1
, NULL_TREE
);
712 if (TYPE_ATTRIBUTES (t2
) != NULL_TREE
)
713 t2
= build_type_attribute_variant (t2
, NULL_TREE
);
715 /* Save time if the two types are the same. */
717 if (t1
== t2
) return t1
;
719 code1
= TREE_CODE (t1
);
720 code2
= TREE_CODE (t2
);
722 gcc_assert (code1
== VECTOR_TYPE
|| code1
== COMPLEX_TYPE
723 || code1
== FIXED_POINT_TYPE
|| code1
== REAL_TYPE
724 || code1
== INTEGER_TYPE
);
725 gcc_assert (code2
== VECTOR_TYPE
|| code2
== COMPLEX_TYPE
726 || code2
== FIXED_POINT_TYPE
|| code2
== REAL_TYPE
727 || code2
== INTEGER_TYPE
);
729 /* When one operand is a decimal float type, the other operand cannot be
730 a generic float type or a complex type. We also disallow vector types
732 if ((DECIMAL_FLOAT_TYPE_P (t1
) || DECIMAL_FLOAT_TYPE_P (t2
))
733 && !(DECIMAL_FLOAT_TYPE_P (t1
) && DECIMAL_FLOAT_TYPE_P (t2
)))
735 if (code1
== VECTOR_TYPE
|| code2
== VECTOR_TYPE
)
737 error ("can%'t mix operands of decimal float and vector types");
738 return error_mark_node
;
740 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
742 error ("can%'t mix operands of decimal float and complex types");
743 return error_mark_node
;
745 if (code1
== REAL_TYPE
&& code2
== REAL_TYPE
)
747 error ("can%'t mix operands of decimal float and other float types");
748 return error_mark_node
;
752 /* If one type is a vector type, return that type. (How the usual
753 arithmetic conversions apply to the vector types extension is not
754 precisely specified.) */
755 if (code1
== VECTOR_TYPE
)
758 if (code2
== VECTOR_TYPE
)
761 /* If one type is complex, form the common type of the non-complex
762 components, then make that complex. Use T1 or T2 if it is the
764 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
766 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
767 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
768 tree subtype
= c_common_type (subtype1
, subtype2
);
770 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
772 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
775 return build_complex_type (subtype
);
778 /* If only one is real, use it as the result. */
780 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
783 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
786 /* If both are real and either are decimal floating point types, use
787 the decimal floating point type with the greater precision. */
789 if (code1
== REAL_TYPE
&& code2
== REAL_TYPE
)
791 if (TYPE_MAIN_VARIANT (t1
) == dfloat128_type_node
792 || TYPE_MAIN_VARIANT (t2
) == dfloat128_type_node
)
793 return dfloat128_type_node
;
794 else if (TYPE_MAIN_VARIANT (t1
) == dfloat64_type_node
795 || TYPE_MAIN_VARIANT (t2
) == dfloat64_type_node
)
796 return dfloat64_type_node
;
797 else if (TYPE_MAIN_VARIANT (t1
) == dfloat32_type_node
798 || TYPE_MAIN_VARIANT (t2
) == dfloat32_type_node
)
799 return dfloat32_type_node
;
802 /* Deal with fixed-point types. */
803 if (code1
== FIXED_POINT_TYPE
|| code2
== FIXED_POINT_TYPE
)
805 unsigned int unsignedp
= 0, satp
= 0;
806 enum machine_mode m1
, m2
;
807 unsigned int fbit1
, ibit1
, fbit2
, ibit2
, max_fbit
, max_ibit
;
812 /* If one input type is saturating, the result type is saturating. */
813 if (TYPE_SATURATING (t1
) || TYPE_SATURATING (t2
))
816 /* If both fixed-point types are unsigned, the result type is unsigned.
817 When mixing fixed-point and integer types, follow the sign of the
819 Otherwise, the result type is signed. */
820 if ((TYPE_UNSIGNED (t1
) && TYPE_UNSIGNED (t2
)
821 && code1
== FIXED_POINT_TYPE
&& code2
== FIXED_POINT_TYPE
)
822 || (code1
== FIXED_POINT_TYPE
&& code2
!= FIXED_POINT_TYPE
823 && TYPE_UNSIGNED (t1
))
824 || (code1
!= FIXED_POINT_TYPE
&& code2
== FIXED_POINT_TYPE
825 && TYPE_UNSIGNED (t2
)))
828 /* The result type is signed. */
831 /* If the input type is unsigned, we need to convert to the
833 if (code1
== FIXED_POINT_TYPE
&& TYPE_UNSIGNED (t1
))
835 enum mode_class mclass
= (enum mode_class
) 0;
836 if (GET_MODE_CLASS (m1
) == MODE_UFRACT
)
838 else if (GET_MODE_CLASS (m1
) == MODE_UACCUM
)
842 m1
= mode_for_size (GET_MODE_PRECISION (m1
), mclass
, 0);
844 if (code2
== FIXED_POINT_TYPE
&& TYPE_UNSIGNED (t2
))
846 enum mode_class mclass
= (enum mode_class
) 0;
847 if (GET_MODE_CLASS (m2
) == MODE_UFRACT
)
849 else if (GET_MODE_CLASS (m2
) == MODE_UACCUM
)
853 m2
= mode_for_size (GET_MODE_PRECISION (m2
), mclass
, 0);
857 if (code1
== FIXED_POINT_TYPE
)
859 fbit1
= GET_MODE_FBIT (m1
);
860 ibit1
= GET_MODE_IBIT (m1
);
865 /* Signed integers need to subtract one sign bit. */
866 ibit1
= TYPE_PRECISION (t1
) - (!TYPE_UNSIGNED (t1
));
869 if (code2
== FIXED_POINT_TYPE
)
871 fbit2
= GET_MODE_FBIT (m2
);
872 ibit2
= GET_MODE_IBIT (m2
);
877 /* Signed integers need to subtract one sign bit. */
878 ibit2
= TYPE_PRECISION (t2
) - (!TYPE_UNSIGNED (t2
));
881 max_ibit
= ibit1
>= ibit2
? ibit1
: ibit2
;
882 max_fbit
= fbit1
>= fbit2
? fbit1
: fbit2
;
883 return c_common_fixed_point_type_for_size (max_ibit
, max_fbit
, unsignedp
,
887 /* Both real or both integers; use the one with greater precision. */
889 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
891 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
894 /* Same precision. Prefer long longs to longs to ints when the
895 same precision, following the C99 rules on integer type rank
896 (which are equivalent to the C90 rules for C90 types). */
898 if (TYPE_MAIN_VARIANT (t1
) == long_long_unsigned_type_node
899 || TYPE_MAIN_VARIANT (t2
) == long_long_unsigned_type_node
)
900 return long_long_unsigned_type_node
;
902 if (TYPE_MAIN_VARIANT (t1
) == long_long_integer_type_node
903 || TYPE_MAIN_VARIANT (t2
) == long_long_integer_type_node
)
905 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
906 return long_long_unsigned_type_node
;
908 return long_long_integer_type_node
;
911 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
912 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
913 return long_unsigned_type_node
;
915 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
916 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
918 /* But preserve unsignedness from the other type,
919 since long cannot hold all the values of an unsigned int. */
920 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
921 return long_unsigned_type_node
;
923 return long_integer_type_node
;
926 /* Likewise, prefer long double to double even if same size. */
927 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
928 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
929 return long_double_type_node
;
931 /* Otherwise prefer the unsigned one. */
933 if (TYPE_UNSIGNED (t1
))
939 /* Wrapper around c_common_type that is used by c-common.c and other
940 front end optimizations that remove promotions. ENUMERAL_TYPEs
941 are allowed here and are converted to their compatible integer types.
942 BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
943 preferably a non-Boolean type as the common type. */
945 common_type (tree t1
, tree t2
)
947 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
948 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), 1);
949 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
950 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), 1);
952 /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
953 if (TREE_CODE (t1
) == BOOLEAN_TYPE
954 && TREE_CODE (t2
) == BOOLEAN_TYPE
)
955 return boolean_type_node
;
957 /* If either type is BOOLEAN_TYPE, then return the other. */
958 if (TREE_CODE (t1
) == BOOLEAN_TYPE
)
960 if (TREE_CODE (t2
) == BOOLEAN_TYPE
)
963 return c_common_type (t1
, t2
);
966 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
967 or various other operations. Return 2 if they are compatible
968 but a warning may be needed if you use them together. */
971 comptypes (tree type1
, tree type2
)
973 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
976 val
= comptypes_internal (type1
, type2
, NULL
, NULL
);
977 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
982 /* Like comptypes, but if it returns non-zero because enum and int are
983 compatible, it sets *ENUM_AND_INT_P to true. */
986 comptypes_check_enum_int (tree type1
, tree type2
, bool *enum_and_int_p
)
988 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
991 val
= comptypes_internal (type1
, type2
, enum_and_int_p
, NULL
);
992 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
997 /* Like comptypes, but if it returns nonzero for different types, it
998 sets *DIFFERENT_TYPES_P to true. */
1001 comptypes_check_different_types (tree type1
, tree type2
,
1002 bool *different_types_p
)
1004 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
1007 val
= comptypes_internal (type1
, type2
, NULL
, different_types_p
);
1008 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
1013 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1014 or various other operations. Return 2 if they are compatible
1015 but a warning may be needed if you use them together. If
1016 ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1017 compatible integer type, then this sets *ENUM_AND_INT_P to true;
1018 *ENUM_AND_INT_P is never set to false. If DIFFERENT_TYPES_P is not
1019 NULL, and the types are compatible but different enough not to be
1020 permitted in C1X typedef redeclarations, then this sets
1021 *DIFFERENT_TYPES_P to true; *DIFFERENT_TYPES_P is never set to
1022 false, but may or may not be set if the types are incompatible.
1023 This differs from comptypes, in that we don't free the seen
1027 comptypes_internal (const_tree type1
, const_tree type2
, bool *enum_and_int_p
,
1028 bool *different_types_p
)
1030 const_tree t1
= type1
;
1031 const_tree t2
= type2
;
1034 /* Suppress errors caused by previously reported errors. */
1036 if (t1
== t2
|| !t1
|| !t2
1037 || TREE_CODE (t1
) == ERROR_MARK
|| TREE_CODE (t2
) == ERROR_MARK
)
1040 /* If either type is the internal version of sizetype, return the
1041 language version. */
1042 if (TREE_CODE (t1
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t1
)
1043 && TYPE_ORIG_SIZE_TYPE (t1
))
1044 t1
= TYPE_ORIG_SIZE_TYPE (t1
);
1046 if (TREE_CODE (t2
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t2
)
1047 && TYPE_ORIG_SIZE_TYPE (t2
))
1048 t2
= TYPE_ORIG_SIZE_TYPE (t2
);
1051 /* Enumerated types are compatible with integer types, but this is
1052 not transitive: two enumerated types in the same translation unit
1053 are compatible with each other only if they are the same type. */
1055 if (TREE_CODE (t1
) == ENUMERAL_TYPE
&& TREE_CODE (t2
) != ENUMERAL_TYPE
)
1057 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), TYPE_UNSIGNED (t1
));
1058 if (TREE_CODE (t2
) != VOID_TYPE
)
1060 if (enum_and_int_p
!= NULL
)
1061 *enum_and_int_p
= true;
1062 if (different_types_p
!= NULL
)
1063 *different_types_p
= true;
1066 else if (TREE_CODE (t2
) == ENUMERAL_TYPE
&& TREE_CODE (t1
) != ENUMERAL_TYPE
)
1068 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), TYPE_UNSIGNED (t2
));
1069 if (TREE_CODE (t1
) != VOID_TYPE
)
1071 if (enum_and_int_p
!= NULL
)
1072 *enum_and_int_p
= true;
1073 if (different_types_p
!= NULL
)
1074 *different_types_p
= true;
1081 /* Different classes of types can't be compatible. */
1083 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1086 /* Qualifiers must match. C99 6.7.3p9 */
1088 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
1091 /* Allow for two different type nodes which have essentially the same
1092 definition. Note that we already checked for equality of the type
1093 qualifiers (just above). */
1095 if (TREE_CODE (t1
) != ARRAY_TYPE
1096 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1099 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1100 if (!(attrval
= targetm
.comp_type_attributes (t1
, t2
)))
1103 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1106 switch (TREE_CODE (t1
))
1109 /* Do not remove mode or aliasing information. */
1110 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1111 || TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
))
1113 val
= (TREE_TYPE (t1
) == TREE_TYPE (t2
)
1114 ? 1 : comptypes_internal (TREE_TYPE (t1
), TREE_TYPE (t2
),
1115 enum_and_int_p
, different_types_p
));
1119 val
= function_types_compatible_p (t1
, t2
, enum_and_int_p
,
1125 tree d1
= TYPE_DOMAIN (t1
);
1126 tree d2
= TYPE_DOMAIN (t2
);
1127 bool d1_variable
, d2_variable
;
1128 bool d1_zero
, d2_zero
;
1131 /* Target types must match incl. qualifiers. */
1132 if (TREE_TYPE (t1
) != TREE_TYPE (t2
)
1133 && 0 == (val
= comptypes_internal (TREE_TYPE (t1
), TREE_TYPE (t2
),
1135 different_types_p
)))
1138 if (different_types_p
!= NULL
1139 && (d1
== 0) != (d2
== 0))
1140 *different_types_p
= true;
1141 /* Sizes must match unless one is missing or variable. */
1142 if (d1
== 0 || d2
== 0 || d1
== d2
)
1145 d1_zero
= !TYPE_MAX_VALUE (d1
);
1146 d2_zero
= !TYPE_MAX_VALUE (d2
);
1148 d1_variable
= (!d1_zero
1149 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
1150 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
1151 d2_variable
= (!d2_zero
1152 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
1153 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
1154 d1_variable
= d1_variable
|| (d1_zero
&& c_vla_type_p (t1
));
1155 d2_variable
= d2_variable
|| (d2_zero
&& c_vla_type_p (t2
));
1157 if (different_types_p
!= NULL
1158 && d1_variable
!= d2_variable
)
1159 *different_types_p
= true;
1160 if (d1_variable
|| d2_variable
)
1162 if (d1_zero
&& d2_zero
)
1164 if (d1_zero
|| d2_zero
1165 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
))
1166 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1
), TYPE_MAX_VALUE (d2
)))
1175 if (val
!= 1 && !same_translation_unit_p (t1
, t2
))
1177 tree a1
= TYPE_ATTRIBUTES (t1
);
1178 tree a2
= TYPE_ATTRIBUTES (t2
);
1180 if (! attribute_list_contained (a1
, a2
)
1181 && ! attribute_list_contained (a2
, a1
))
1185 return tagged_types_tu_compatible_p (t1
, t2
, enum_and_int_p
,
1187 val
= tagged_types_tu_compatible_p (t1
, t2
, enum_and_int_p
,
1193 val
= (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1194 && comptypes_internal (TREE_TYPE (t1
), TREE_TYPE (t2
),
1195 enum_and_int_p
, different_types_p
));
1201 return attrval
== 2 && val
== 1 ? 2 : val
;
1204 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1205 their qualifiers, except for named address spaces. If the pointers point to
1206 different named addresses, then we must determine if one address space is a
1207 subset of the other. */
1210 comp_target_types (location_t location
, tree ttl
, tree ttr
)
1213 tree mvl
= TREE_TYPE (ttl
);
1214 tree mvr
= TREE_TYPE (ttr
);
1215 addr_space_t asl
= TYPE_ADDR_SPACE (mvl
);
1216 addr_space_t asr
= TYPE_ADDR_SPACE (mvr
);
1217 addr_space_t as_common
;
1218 bool enum_and_int_p
;
1220 /* Fail if pointers point to incompatible address spaces. */
1221 if (!addr_space_superset (asl
, asr
, &as_common
))
1224 /* Do not lose qualifiers on element types of array types that are
1225 pointer targets by taking their TYPE_MAIN_VARIANT. */
1226 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
1227 mvl
= TYPE_MAIN_VARIANT (mvl
);
1228 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
1229 mvr
= TYPE_MAIN_VARIANT (mvr
);
1230 enum_and_int_p
= false;
1231 val
= comptypes_check_enum_int (mvl
, mvr
, &enum_and_int_p
);
1234 pedwarn (location
, OPT_pedantic
, "types are not quite compatible");
1236 if (val
== 1 && enum_and_int_p
&& warn_cxx_compat
)
1237 warning_at (location
, OPT_Wc___compat
,
1238 "pointer target types incompatible in C++");
1243 /* Subroutines of `comptypes'. */
1245 /* Determine whether two trees derive from the same translation unit.
1246 If the CONTEXT chain ends in a null, that tree's context is still
1247 being parsed, so if two trees have context chains ending in null,
1248 they're in the same translation unit. */
1250 same_translation_unit_p (const_tree t1
, const_tree t2
)
1252 while (t1
&& TREE_CODE (t1
) != TRANSLATION_UNIT_DECL
)
1253 switch (TREE_CODE_CLASS (TREE_CODE (t1
)))
1255 case tcc_declaration
:
1256 t1
= DECL_CONTEXT (t1
); break;
1258 t1
= TYPE_CONTEXT (t1
); break;
1259 case tcc_exceptional
:
1260 t1
= BLOCK_SUPERCONTEXT (t1
); break; /* assume block */
1261 default: gcc_unreachable ();
1264 while (t2
&& TREE_CODE (t2
) != TRANSLATION_UNIT_DECL
)
1265 switch (TREE_CODE_CLASS (TREE_CODE (t2
)))
1267 case tcc_declaration
:
1268 t2
= DECL_CONTEXT (t2
); break;
1270 t2
= TYPE_CONTEXT (t2
); break;
1271 case tcc_exceptional
:
1272 t2
= BLOCK_SUPERCONTEXT (t2
); break; /* assume block */
1273 default: gcc_unreachable ();
1279 /* Allocate the seen two types, assuming that they are compatible. */
1281 static struct tagged_tu_seen_cache
*
1282 alloc_tagged_tu_seen_cache (const_tree t1
, const_tree t2
)
1284 struct tagged_tu_seen_cache
*tu
= XNEW (struct tagged_tu_seen_cache
);
1285 tu
->next
= tagged_tu_seen_base
;
1289 tagged_tu_seen_base
= tu
;
1291 /* The C standard says that two structures in different translation
1292 units are compatible with each other only if the types of their
1293 fields are compatible (among other things). We assume that they
1294 are compatible until proven otherwise when building the cache.
1295 An example where this can occur is:
1300 If we are comparing this against a similar struct in another TU,
1301 and did not assume they were compatible, we end up with an infinite
1307 /* Free the seen types until we get to TU_TIL. */
1310 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache
*tu_til
)
1312 const struct tagged_tu_seen_cache
*tu
= tagged_tu_seen_base
;
1313 while (tu
!= tu_til
)
1315 const struct tagged_tu_seen_cache
*const tu1
1316 = (const struct tagged_tu_seen_cache
*) tu
;
1318 free (CONST_CAST (struct tagged_tu_seen_cache
*, tu1
));
1320 tagged_tu_seen_base
= tu_til
;
1323 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1324 compatible. If the two types are not the same (which has been
1325 checked earlier), this can only happen when multiple translation
1326 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
1327 rules. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1328 comptypes_internal. */
1331 tagged_types_tu_compatible_p (const_tree t1
, const_tree t2
,
1332 bool *enum_and_int_p
, bool *different_types_p
)
1335 bool needs_warning
= false;
1337 /* We have to verify that the tags of the types are the same. This
1338 is harder than it looks because this may be a typedef, so we have
1339 to go look at the original type. It may even be a typedef of a
1341 In the case of compiler-created builtin structs the TYPE_DECL
1342 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
1343 while (TYPE_NAME (t1
)
1344 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1345 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1
)))
1346 t1
= DECL_ORIGINAL_TYPE (TYPE_NAME (t1
));
1348 while (TYPE_NAME (t2
)
1349 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
1350 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2
)))
1351 t2
= DECL_ORIGINAL_TYPE (TYPE_NAME (t2
));
1353 /* C90 didn't have the requirement that the two tags be the same. */
1354 if (flag_isoc99
&& TYPE_NAME (t1
) != TYPE_NAME (t2
))
1357 /* C90 didn't say what happened if one or both of the types were
1358 incomplete; we choose to follow C99 rules here, which is that they
1360 if (TYPE_SIZE (t1
) == NULL
1361 || TYPE_SIZE (t2
) == NULL
)
1365 const struct tagged_tu_seen_cache
* tts_i
;
1366 for (tts_i
= tagged_tu_seen_base
; tts_i
!= NULL
; tts_i
= tts_i
->next
)
1367 if (tts_i
->t1
== t1
&& tts_i
->t2
== t2
)
1371 switch (TREE_CODE (t1
))
1375 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1376 /* Speed up the case where the type values are in the same order. */
1377 tree tv1
= TYPE_VALUES (t1
);
1378 tree tv2
= TYPE_VALUES (t2
);
1385 for (;tv1
&& tv2
; tv1
= TREE_CHAIN (tv1
), tv2
= TREE_CHAIN (tv2
))
1387 if (TREE_PURPOSE (tv1
) != TREE_PURPOSE (tv2
))
1389 if (simple_cst_equal (TREE_VALUE (tv1
), TREE_VALUE (tv2
)) != 1)
1396 if (tv1
== NULL_TREE
&& tv2
== NULL_TREE
)
1400 if (tv1
== NULL_TREE
|| tv2
== NULL_TREE
)
1406 if (list_length (TYPE_VALUES (t1
)) != list_length (TYPE_VALUES (t2
)))
1412 for (s1
= TYPE_VALUES (t1
); s1
; s1
= TREE_CHAIN (s1
))
1414 s2
= purpose_member (TREE_PURPOSE (s1
), TYPE_VALUES (t2
));
1416 || simple_cst_equal (TREE_VALUE (s1
), TREE_VALUE (s2
)) != 1)
1427 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1428 if (list_length (TYPE_FIELDS (t1
)) != list_length (TYPE_FIELDS (t2
)))
1434 /* Speed up the common case where the fields are in the same order. */
1435 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
); s1
&& s2
;
1436 s1
= TREE_CHAIN (s1
), s2
= TREE_CHAIN (s2
))
1440 if (DECL_NAME (s1
) != DECL_NAME (s2
))
1442 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1443 enum_and_int_p
, different_types_p
);
1445 if (result
!= 1 && !DECL_NAME (s1
))
1453 needs_warning
= true;
1455 if (TREE_CODE (s1
) == FIELD_DECL
1456 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1457 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1465 tu
->val
= needs_warning
? 2 : 1;
1469 for (s1
= TYPE_FIELDS (t1
); s1
; s1
= TREE_CHAIN (s1
))
1473 for (s2
= TYPE_FIELDS (t2
); s2
; s2
= TREE_CHAIN (s2
))
1474 if (DECL_NAME (s1
) == DECL_NAME (s2
))
1478 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1482 if (result
!= 1 && !DECL_NAME (s1
))
1490 needs_warning
= true;
1492 if (TREE_CODE (s1
) == FIELD_DECL
1493 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1494 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1506 tu
->val
= needs_warning
? 2 : 10;
1512 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1514 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
);
1516 s1
= TREE_CHAIN (s1
), s2
= TREE_CHAIN (s2
))
1519 if (TREE_CODE (s1
) != TREE_CODE (s2
)
1520 || DECL_NAME (s1
) != DECL_NAME (s2
))
1522 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1523 enum_and_int_p
, different_types_p
);
1527 needs_warning
= true;
1529 if (TREE_CODE (s1
) == FIELD_DECL
1530 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1531 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1537 tu
->val
= needs_warning
? 2 : 1;
1546 /* Return 1 if two function types F1 and F2 are compatible.
1547 If either type specifies no argument types,
1548 the other must specify a fixed number of self-promoting arg types.
1549 Otherwise, if one type specifies only the number of arguments,
1550 the other must specify that number of self-promoting arg types.
1551 Otherwise, the argument types must match.
1552 ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in comptypes_internal. */
1555 function_types_compatible_p (const_tree f1
, const_tree f2
,
1556 bool *enum_and_int_p
, bool *different_types_p
)
1559 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1564 ret1
= TREE_TYPE (f1
);
1565 ret2
= TREE_TYPE (f2
);
1567 /* 'volatile' qualifiers on a function's return type used to mean
1568 the function is noreturn. */
1569 if (TYPE_VOLATILE (ret1
) != TYPE_VOLATILE (ret2
))
1570 pedwarn (input_location
, 0, "function return types not compatible due to %<volatile%>");
1571 if (TYPE_VOLATILE (ret1
))
1572 ret1
= build_qualified_type (TYPE_MAIN_VARIANT (ret1
),
1573 TYPE_QUALS (ret1
) & ~TYPE_QUAL_VOLATILE
);
1574 if (TYPE_VOLATILE (ret2
))
1575 ret2
= build_qualified_type (TYPE_MAIN_VARIANT (ret2
),
1576 TYPE_QUALS (ret2
) & ~TYPE_QUAL_VOLATILE
);
1577 val
= comptypes_internal (ret1
, ret2
, enum_and_int_p
, different_types_p
);
1581 args1
= TYPE_ARG_TYPES (f1
);
1582 args2
= TYPE_ARG_TYPES (f2
);
1584 if (different_types_p
!= NULL
1585 && (args1
== 0) != (args2
== 0))
1586 *different_types_p
= true;
1588 /* An unspecified parmlist matches any specified parmlist
1589 whose argument types don't need default promotions. */
1593 if (!self_promoting_args_p (args2
))
1595 /* If one of these types comes from a non-prototype fn definition,
1596 compare that with the other type's arglist.
1597 If they don't match, ask for a warning (but no error). */
1598 if (TYPE_ACTUAL_ARG_TYPES (f1
)
1599 && 1 != type_lists_compatible_p (args2
, TYPE_ACTUAL_ARG_TYPES (f1
),
1600 enum_and_int_p
, different_types_p
))
1606 if (!self_promoting_args_p (args1
))
1608 if (TYPE_ACTUAL_ARG_TYPES (f2
)
1609 && 1 != type_lists_compatible_p (args1
, TYPE_ACTUAL_ARG_TYPES (f2
),
1610 enum_and_int_p
, different_types_p
))
1615 /* Both types have argument lists: compare them and propagate results. */
1616 val1
= type_lists_compatible_p (args1
, args2
, enum_and_int_p
,
1618 return val1
!= 1 ? val1
: val
;
1621 /* Check two lists of types for compatibility, returning 0 for
1622 incompatible, 1 for compatible, or 2 for compatible with
1623 warning. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1624 comptypes_internal. */
1627 type_lists_compatible_p (const_tree args1
, const_tree args2
,
1628 bool *enum_and_int_p
, bool *different_types_p
)
1630 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1636 tree a1
, mv1
, a2
, mv2
;
1637 if (args1
== 0 && args2
== 0)
1639 /* If one list is shorter than the other,
1640 they fail to match. */
1641 if (args1
== 0 || args2
== 0)
1643 mv1
= a1
= TREE_VALUE (args1
);
1644 mv2
= a2
= TREE_VALUE (args2
);
1645 if (mv1
&& mv1
!= error_mark_node
&& TREE_CODE (mv1
) != ARRAY_TYPE
)
1646 mv1
= TYPE_MAIN_VARIANT (mv1
);
1647 if (mv2
&& mv2
!= error_mark_node
&& TREE_CODE (mv2
) != ARRAY_TYPE
)
1648 mv2
= TYPE_MAIN_VARIANT (mv2
);
1649 /* A null pointer instead of a type
1650 means there is supposed to be an argument
1651 but nothing is specified about what type it has.
1652 So match anything that self-promotes. */
1653 if (different_types_p
!= NULL
1654 && (a1
== 0) != (a2
== 0))
1655 *different_types_p
= true;
1658 if (c_type_promotes_to (a2
) != a2
)
1663 if (c_type_promotes_to (a1
) != a1
)
1666 /* If one of the lists has an error marker, ignore this arg. */
1667 else if (TREE_CODE (a1
) == ERROR_MARK
1668 || TREE_CODE (a2
) == ERROR_MARK
)
1670 else if (!(newval
= comptypes_internal (mv1
, mv2
, enum_and_int_p
,
1671 different_types_p
)))
1673 if (different_types_p
!= NULL
)
1674 *different_types_p
= true;
1675 /* Allow wait (union {union wait *u; int *i} *)
1676 and wait (union wait *) to be compatible. */
1677 if (TREE_CODE (a1
) == UNION_TYPE
1678 && (TYPE_NAME (a1
) == 0
1679 || TYPE_TRANSPARENT_AGGR (a1
))
1680 && TREE_CODE (TYPE_SIZE (a1
)) == INTEGER_CST
1681 && tree_int_cst_equal (TYPE_SIZE (a1
),
1685 for (memb
= TYPE_FIELDS (a1
);
1686 memb
; memb
= TREE_CHAIN (memb
))
1688 tree mv3
= TREE_TYPE (memb
);
1689 if (mv3
&& mv3
!= error_mark_node
1690 && TREE_CODE (mv3
) != ARRAY_TYPE
)
1691 mv3
= TYPE_MAIN_VARIANT (mv3
);
1692 if (comptypes_internal (mv3
, mv2
, enum_and_int_p
,
1699 else if (TREE_CODE (a2
) == UNION_TYPE
1700 && (TYPE_NAME (a2
) == 0
1701 || TYPE_TRANSPARENT_AGGR (a2
))
1702 && TREE_CODE (TYPE_SIZE (a2
)) == INTEGER_CST
1703 && tree_int_cst_equal (TYPE_SIZE (a2
),
1707 for (memb
= TYPE_FIELDS (a2
);
1708 memb
; memb
= TREE_CHAIN (memb
))
1710 tree mv3
= TREE_TYPE (memb
);
1711 if (mv3
&& mv3
!= error_mark_node
1712 && TREE_CODE (mv3
) != ARRAY_TYPE
)
1713 mv3
= TYPE_MAIN_VARIANT (mv3
);
1714 if (comptypes_internal (mv3
, mv1
, enum_and_int_p
,
1725 /* comptypes said ok, but record if it said to warn. */
1729 args1
= TREE_CHAIN (args1
);
1730 args2
= TREE_CHAIN (args2
);
1734 /* Compute the size to increment a pointer by. */
1737 c_size_in_bytes (const_tree type
)
1739 enum tree_code code
= TREE_CODE (type
);
1741 if (code
== FUNCTION_TYPE
|| code
== VOID_TYPE
|| code
== ERROR_MARK
)
1742 return size_one_node
;
1744 if (!COMPLETE_OR_VOID_TYPE_P (type
))
1746 error ("arithmetic on pointer to an incomplete type");
1747 return size_one_node
;
1750 /* Convert in case a char is more than one unit. */
1751 return size_binop_loc (input_location
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
1752 size_int (TYPE_PRECISION (char_type_node
)
1756 /* Return either DECL or its known constant value (if it has one). */
1759 decl_constant_value (tree decl
)
1761 if (/* Don't change a variable array bound or initial value to a constant
1762 in a place where a variable is invalid. Note that DECL_INITIAL
1763 isn't valid for a PARM_DECL. */
1764 current_function_decl
!= 0
1765 && TREE_CODE (decl
) != PARM_DECL
1766 && !TREE_THIS_VOLATILE (decl
)
1767 && TREE_READONLY (decl
)
1768 && DECL_INITIAL (decl
) != 0
1769 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
1770 /* This is invalid if initial value is not constant.
1771 If it has either a function call, a memory reference,
1772 or a variable, then re-evaluating it could give different results. */
1773 && TREE_CONSTANT (DECL_INITIAL (decl
))
1774 /* Check for cases where this is sub-optimal, even though valid. */
1775 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1776 return DECL_INITIAL (decl
);
1780 /* Convert the array expression EXP to a pointer. */
1782 array_to_pointer_conversion (location_t loc
, tree exp
)
1784 tree orig_exp
= exp
;
1785 tree type
= TREE_TYPE (exp
);
1787 tree restype
= TREE_TYPE (type
);
1790 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
1792 STRIP_TYPE_NOPS (exp
);
1794 if (TREE_NO_WARNING (orig_exp
))
1795 TREE_NO_WARNING (exp
) = 1;
1797 ptrtype
= build_pointer_type (restype
);
1799 if (TREE_CODE (exp
) == INDIRECT_REF
)
1800 return convert (ptrtype
, TREE_OPERAND (exp
, 0));
1802 adr
= build_unary_op (loc
, ADDR_EXPR
, exp
, 1);
1803 return convert (ptrtype
, adr
);
1806 /* Convert the function expression EXP to a pointer. */
1808 function_to_pointer_conversion (location_t loc
, tree exp
)
1810 tree orig_exp
= exp
;
1812 gcc_assert (TREE_CODE (TREE_TYPE (exp
)) == FUNCTION_TYPE
);
1814 STRIP_TYPE_NOPS (exp
);
1816 if (TREE_NO_WARNING (orig_exp
))
1817 TREE_NO_WARNING (exp
) = 1;
1819 return build_unary_op (loc
, ADDR_EXPR
, exp
, 0);
1822 /* Mark EXP as read, not just set, for set but not used -Wunused
1823 warning purposes. */
1826 mark_exp_read (tree exp
)
1828 switch (TREE_CODE (exp
))
1832 DECL_READ_P (exp
) = 1;
1841 mark_exp_read (TREE_OPERAND (exp
, 0));
1844 case C_MAYBE_CONST_EXPR
:
1845 mark_exp_read (TREE_OPERAND (exp
, 1));
1852 /* Perform the default conversion of arrays and functions to pointers.
1853 Return the result of converting EXP. For any other expression, just
1856 LOC is the location of the expression. */
1859 default_function_array_conversion (location_t loc
, struct c_expr exp
)
1861 tree orig_exp
= exp
.value
;
1862 tree type
= TREE_TYPE (exp
.value
);
1863 enum tree_code code
= TREE_CODE (type
);
1869 bool not_lvalue
= false;
1870 bool lvalue_array_p
;
1872 while ((TREE_CODE (exp
.value
) == NON_LVALUE_EXPR
1873 || CONVERT_EXPR_P (exp
.value
))
1874 && TREE_TYPE (TREE_OPERAND (exp
.value
, 0)) == type
)
1876 if (TREE_CODE (exp
.value
) == NON_LVALUE_EXPR
)
1878 exp
.value
= TREE_OPERAND (exp
.value
, 0);
1881 if (TREE_NO_WARNING (orig_exp
))
1882 TREE_NO_WARNING (exp
.value
) = 1;
1884 lvalue_array_p
= !not_lvalue
&& lvalue_p (exp
.value
);
1885 if (!flag_isoc99
&& !lvalue_array_p
)
1887 /* Before C99, non-lvalue arrays do not decay to pointers.
1888 Normally, using such an array would be invalid; but it can
1889 be used correctly inside sizeof or as a statement expression.
1890 Thus, do not give an error here; an error will result later. */
1894 exp
.value
= array_to_pointer_conversion (loc
, exp
.value
);
1898 exp
.value
= function_to_pointer_conversion (loc
, exp
.value
);
1908 default_function_array_read_conversion (location_t loc
, struct c_expr exp
)
1910 mark_exp_read (exp
.value
);
1911 return default_function_array_conversion (loc
, exp
);
1914 /* EXP is an expression of integer type. Apply the integer promotions
1915 to it and return the promoted value. */
1918 perform_integral_promotions (tree exp
)
1920 tree type
= TREE_TYPE (exp
);
1921 enum tree_code code
= TREE_CODE (type
);
1923 gcc_assert (INTEGRAL_TYPE_P (type
));
1925 /* Normally convert enums to int,
1926 but convert wide enums to something wider. */
1927 if (code
== ENUMERAL_TYPE
)
1929 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
1930 TYPE_PRECISION (integer_type_node
)),
1931 ((TYPE_PRECISION (type
)
1932 >= TYPE_PRECISION (integer_type_node
))
1933 && TYPE_UNSIGNED (type
)));
1935 return convert (type
, exp
);
1938 /* ??? This should no longer be needed now bit-fields have their
1940 if (TREE_CODE (exp
) == COMPONENT_REF
1941 && DECL_C_BIT_FIELD (TREE_OPERAND (exp
, 1))
1942 /* If it's thinner than an int, promote it like a
1943 c_promoting_integer_type_p, otherwise leave it alone. */
1944 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp
, 1)),
1945 TYPE_PRECISION (integer_type_node
)))
1946 return convert (integer_type_node
, exp
);
1948 if (c_promoting_integer_type_p (type
))
1950 /* Preserve unsignedness if not really getting any wider. */
1951 if (TYPE_UNSIGNED (type
)
1952 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1953 return convert (unsigned_type_node
, exp
);
1955 return convert (integer_type_node
, exp
);
1962 /* Perform default promotions for C data used in expressions.
1963 Enumeral types or short or char are converted to int.
1964 In addition, manifest constants symbols are replaced by their values. */
1967 default_conversion (tree exp
)
1970 tree type
= TREE_TYPE (exp
);
1971 enum tree_code code
= TREE_CODE (type
);
1974 mark_exp_read (exp
);
1976 /* Functions and arrays have been converted during parsing. */
1977 gcc_assert (code
!= FUNCTION_TYPE
);
1978 if (code
== ARRAY_TYPE
)
1981 /* Constants can be used directly unless they're not loadable. */
1982 if (TREE_CODE (exp
) == CONST_DECL
)
1983 exp
= DECL_INITIAL (exp
);
1985 /* Strip no-op conversions. */
1987 STRIP_TYPE_NOPS (exp
);
1989 if (TREE_NO_WARNING (orig_exp
))
1990 TREE_NO_WARNING (exp
) = 1;
1992 if (code
== VOID_TYPE
)
1994 error ("void value not ignored as it ought to be");
1995 return error_mark_node
;
1998 exp
= require_complete_type (exp
);
1999 if (exp
== error_mark_node
)
2000 return error_mark_node
;
2002 promoted_type
= targetm
.promoted_type (type
);
2004 return convert (promoted_type
, exp
);
2006 if (INTEGRAL_TYPE_P (type
))
2007 return perform_integral_promotions (exp
);
2012 /* Look up COMPONENT in a structure or union TYPE.
2014 If the component name is not found, returns NULL_TREE. Otherwise,
2015 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
2016 stepping down the chain to the component, which is in the last
2017 TREE_VALUE of the list. Normally the list is of length one, but if
2018 the component is embedded within (nested) anonymous structures or
2019 unions, the list steps down the chain to the component. */
2022 lookup_field (tree type
, tree component
)
2026 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
2027 to the field elements. Use a binary search on this array to quickly
2028 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
2029 will always be set for structures which have many elements. */
2031 if (TYPE_LANG_SPECIFIC (type
) && TYPE_LANG_SPECIFIC (type
)->s
)
2034 tree
*field_array
= &TYPE_LANG_SPECIFIC (type
)->s
->elts
[0];
2036 field
= TYPE_FIELDS (type
);
2038 top
= TYPE_LANG_SPECIFIC (type
)->s
->len
;
2039 while (top
- bot
> 1)
2041 half
= (top
- bot
+ 1) >> 1;
2042 field
= field_array
[bot
+half
];
2044 if (DECL_NAME (field
) == NULL_TREE
)
2046 /* Step through all anon unions in linear fashion. */
2047 while (DECL_NAME (field_array
[bot
]) == NULL_TREE
)
2049 field
= field_array
[bot
++];
2050 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
2051 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
2053 tree anon
= lookup_field (TREE_TYPE (field
), component
);
2056 return tree_cons (NULL_TREE
, field
, anon
);
2060 /* Entire record is only anon unions. */
2064 /* Restart the binary search, with new lower bound. */
2068 if (DECL_NAME (field
) == component
)
2070 if (DECL_NAME (field
) < component
)
2076 if (DECL_NAME (field_array
[bot
]) == component
)
2077 field
= field_array
[bot
];
2078 else if (DECL_NAME (field
) != component
)
2083 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2085 if (DECL_NAME (field
) == NULL_TREE
2086 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
2087 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
))
2089 tree anon
= lookup_field (TREE_TYPE (field
), component
);
2092 return tree_cons (NULL_TREE
, field
, anon
);
2095 if (DECL_NAME (field
) == component
)
2099 if (field
== NULL_TREE
)
2103 return tree_cons (NULL_TREE
, field
, NULL_TREE
);
2106 /* Make an expression to refer to the COMPONENT field of structure or
2107 union value DATUM. COMPONENT is an IDENTIFIER_NODE. LOC is the
2108 location of the COMPONENT_REF. */
2111 build_component_ref (location_t loc
, tree datum
, tree component
)
2113 tree type
= TREE_TYPE (datum
);
2114 enum tree_code code
= TREE_CODE (type
);
2117 bool datum_lvalue
= lvalue_p (datum
);
2119 if (!objc_is_public (datum
, component
))
2120 return error_mark_node
;
2122 /* See if there is a field or component with name COMPONENT. */
2124 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
2126 if (!COMPLETE_TYPE_P (type
))
2128 c_incomplete_type_error (NULL_TREE
, type
);
2129 return error_mark_node
;
2132 field
= lookup_field (type
, component
);
2136 error_at (loc
, "%qT has no member named %qE", type
, component
);
2137 return error_mark_node
;
2140 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2141 This might be better solved in future the way the C++ front
2142 end does it - by giving the anonymous entities each a
2143 separate name and type, and then have build_component_ref
2144 recursively call itself. We can't do that here. */
2147 tree subdatum
= TREE_VALUE (field
);
2150 bool use_datum_quals
;
2152 if (TREE_TYPE (subdatum
) == error_mark_node
)
2153 return error_mark_node
;
2155 /* If this is an rvalue, it does not have qualifiers in C
2156 standard terms and we must avoid propagating such
2157 qualifiers down to a non-lvalue array that is then
2158 converted to a pointer. */
2159 use_datum_quals
= (datum_lvalue
2160 || TREE_CODE (TREE_TYPE (subdatum
)) != ARRAY_TYPE
);
2162 quals
= TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum
)));
2163 if (use_datum_quals
)
2164 quals
|= TYPE_QUALS (TREE_TYPE (datum
));
2165 subtype
= c_build_qualified_type (TREE_TYPE (subdatum
), quals
);
2167 ref
= build3 (COMPONENT_REF
, subtype
, datum
, subdatum
,
2169 SET_EXPR_LOCATION (ref
, loc
);
2170 if (TREE_READONLY (subdatum
)
2171 || (use_datum_quals
&& TREE_READONLY (datum
)))
2172 TREE_READONLY (ref
) = 1;
2173 if (TREE_THIS_VOLATILE (subdatum
)
2174 || (use_datum_quals
&& TREE_THIS_VOLATILE (datum
)))
2175 TREE_THIS_VOLATILE (ref
) = 1;
2177 if (TREE_DEPRECATED (subdatum
))
2178 warn_deprecated_use (subdatum
, NULL_TREE
);
2182 field
= TREE_CHAIN (field
);
2188 else if (code
!= ERROR_MARK
)
2190 "request for member %qE in something not a structure or union",
2193 return error_mark_node
;
2196 /* Given an expression PTR for a pointer, return an expression
2197 for the value pointed to.
2198 ERRORSTRING is the name of the operator to appear in error messages.
2200 LOC is the location to use for the generated tree. */
2203 build_indirect_ref (location_t loc
, tree ptr
, ref_operator errstring
)
2205 tree pointer
= default_conversion (ptr
);
2206 tree type
= TREE_TYPE (pointer
);
2209 if (TREE_CODE (type
) == POINTER_TYPE
)
2211 if (CONVERT_EXPR_P (pointer
)
2212 || TREE_CODE (pointer
) == VIEW_CONVERT_EXPR
)
2214 /* If a warning is issued, mark it to avoid duplicates from
2215 the backend. This only needs to be done at
2216 warn_strict_aliasing > 2. */
2217 if (warn_strict_aliasing
> 2)
2218 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer
, 0)),
2219 type
, TREE_OPERAND (pointer
, 0)))
2220 TREE_NO_WARNING (pointer
) = 1;
2223 if (TREE_CODE (pointer
) == ADDR_EXPR
2224 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
2225 == TREE_TYPE (type
)))
2227 ref
= TREE_OPERAND (pointer
, 0);
2228 protected_set_expr_location (ref
, loc
);
2233 tree t
= TREE_TYPE (type
);
2235 ref
= build1 (INDIRECT_REF
, t
, pointer
);
2237 if (!COMPLETE_OR_VOID_TYPE_P (t
) && TREE_CODE (t
) != ARRAY_TYPE
)
2239 error_at (loc
, "dereferencing pointer to incomplete type");
2240 return error_mark_node
;
2242 if (VOID_TYPE_P (t
) && c_inhibit_evaluation_warnings
== 0)
2243 warning_at (loc
, 0, "dereferencing %<void *%> pointer");
2245 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2246 so that we get the proper error message if the result is used
2247 to assign to. Also, &* is supposed to be a no-op.
2248 And ANSI C seems to specify that the type of the result
2249 should be the const type. */
2250 /* A de-reference of a pointer to const is not a const. It is valid
2251 to change it via some other pointer. */
2252 TREE_READONLY (ref
) = TYPE_READONLY (t
);
2253 TREE_SIDE_EFFECTS (ref
)
2254 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
2255 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
2256 protected_set_expr_location (ref
, loc
);
2260 else if (TREE_CODE (pointer
) != ERROR_MARK
)
2263 case RO_ARRAY_INDEXING
:
2265 "invalid type argument of array indexing (have %qT)",
2270 "invalid type argument of unary %<*%> (have %qT)",
2275 "invalid type argument of %<->%> (have %qT)",
2281 return error_mark_node
;
2284 /* This handles expressions of the form "a[i]", which denotes
2287 This is logically equivalent in C to *(a+i), but we may do it differently.
2288 If A is a variable or a member, we generate a primitive ARRAY_REF.
2289 This avoids forcing the array out of registers, and can work on
2290 arrays that are not lvalues (for example, members of structures returned
2293 LOC is the location to use for the returned expression. */
2296 build_array_ref (location_t loc
, tree array
, tree index
)
2299 bool swapped
= false;
2300 if (TREE_TYPE (array
) == error_mark_node
2301 || TREE_TYPE (index
) == error_mark_node
)
2302 return error_mark_node
;
2304 if (TREE_CODE (TREE_TYPE (array
)) != ARRAY_TYPE
2305 && TREE_CODE (TREE_TYPE (array
)) != POINTER_TYPE
)
2308 if (TREE_CODE (TREE_TYPE (index
)) != ARRAY_TYPE
2309 && TREE_CODE (TREE_TYPE (index
)) != POINTER_TYPE
)
2311 error_at (loc
, "subscripted value is neither array nor pointer");
2312 return error_mark_node
;
2320 if (!INTEGRAL_TYPE_P (TREE_TYPE (index
)))
2322 error_at (loc
, "array subscript is not an integer");
2323 return error_mark_node
;
2326 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array
))) == FUNCTION_TYPE
)
2328 error_at (loc
, "subscripted value is pointer to function");
2329 return error_mark_node
;
2332 /* ??? Existing practice has been to warn only when the char
2333 index is syntactically the index, not for char[array]. */
2335 warn_array_subscript_with_type_char (index
);
2337 /* Apply default promotions *after* noticing character types. */
2338 index
= default_conversion (index
);
2340 gcc_assert (TREE_CODE (TREE_TYPE (index
)) == INTEGER_TYPE
);
2342 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
2346 /* An array that is indexed by a non-constant
2347 cannot be stored in a register; we must be able to do
2348 address arithmetic on its address.
2349 Likewise an array of elements of variable size. */
2350 if (TREE_CODE (index
) != INTEGER_CST
2351 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
2352 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
2354 if (!c_mark_addressable (array
))
2355 return error_mark_node
;
2357 /* An array that is indexed by a constant value which is not within
2358 the array bounds cannot be stored in a register either; because we
2359 would get a crash in store_bit_field/extract_bit_field when trying
2360 to access a non-existent part of the register. */
2361 if (TREE_CODE (index
) == INTEGER_CST
2362 && TYPE_DOMAIN (TREE_TYPE (array
))
2363 && !int_fits_type_p (index
, TYPE_DOMAIN (TREE_TYPE (array
))))
2365 if (!c_mark_addressable (array
))
2366 return error_mark_node
;
2372 while (TREE_CODE (foo
) == COMPONENT_REF
)
2373 foo
= TREE_OPERAND (foo
, 0);
2374 if (TREE_CODE (foo
) == VAR_DECL
&& C_DECL_REGISTER (foo
))
2375 pedwarn (loc
, OPT_pedantic
,
2376 "ISO C forbids subscripting %<register%> array");
2377 else if (!flag_isoc99
&& !lvalue_p (foo
))
2378 pedwarn (loc
, OPT_pedantic
,
2379 "ISO C90 forbids subscripting non-lvalue array");
2382 type
= TREE_TYPE (TREE_TYPE (array
));
2383 rval
= build4 (ARRAY_REF
, type
, array
, index
, NULL_TREE
, NULL_TREE
);
2384 /* Array ref is const/volatile if the array elements are
2385 or if the array is. */
2386 TREE_READONLY (rval
)
2387 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
2388 | TREE_READONLY (array
));
2389 TREE_SIDE_EFFECTS (rval
)
2390 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
2391 | TREE_SIDE_EFFECTS (array
));
2392 TREE_THIS_VOLATILE (rval
)
2393 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
2394 /* This was added by rms on 16 Nov 91.
2395 It fixes vol struct foo *a; a->elts[1]
2396 in an inline function.
2397 Hope it doesn't break something else. */
2398 | TREE_THIS_VOLATILE (array
));
2399 ret
= require_complete_type (rval
);
2400 protected_set_expr_location (ret
, loc
);
2405 tree ar
= default_conversion (array
);
2407 if (ar
== error_mark_node
)
2410 gcc_assert (TREE_CODE (TREE_TYPE (ar
)) == POINTER_TYPE
);
2411 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar
))) != FUNCTION_TYPE
);
2413 return build_indirect_ref
2414 (loc
, build_binary_op (loc
, PLUS_EXPR
, ar
, index
, 0),
2419 /* Build an external reference to identifier ID. FUN indicates
2420 whether this will be used for a function call. LOC is the source
2421 location of the identifier. This sets *TYPE to the type of the
2422 identifier, which is not the same as the type of the returned value
2423 for CONST_DECLs defined as enum constants. If the type of the
2424 identifier is not available, *TYPE is set to NULL. */
2426 build_external_ref (location_t loc
, tree id
, int fun
, tree
*type
)
2429 tree decl
= lookup_name (id
);
2431 /* In Objective-C, an instance variable (ivar) may be preferred to
2432 whatever lookup_name() found. */
2433 decl
= objc_lookup_ivar (decl
, id
);
2436 if (decl
&& decl
!= error_mark_node
)
2439 *type
= TREE_TYPE (ref
);
2442 /* Implicit function declaration. */
2443 ref
= implicitly_declare (loc
, id
);
2444 else if (decl
== error_mark_node
)
2445 /* Don't complain about something that's already been
2446 complained about. */
2447 return error_mark_node
;
2450 undeclared_variable (loc
, id
);
2451 return error_mark_node
;
2454 if (TREE_TYPE (ref
) == error_mark_node
)
2455 return error_mark_node
;
2457 if (TREE_DEPRECATED (ref
))
2458 warn_deprecated_use (ref
, NULL_TREE
);
2460 /* Recursive call does not count as usage. */
2461 if (ref
!= current_function_decl
)
2463 TREE_USED (ref
) = 1;
2466 if (TREE_CODE (ref
) == FUNCTION_DECL
&& !in_alignof
)
2468 if (!in_sizeof
&& !in_typeof
)
2469 C_DECL_USED (ref
) = 1;
2470 else if (DECL_INITIAL (ref
) == 0
2471 && DECL_EXTERNAL (ref
)
2472 && !TREE_PUBLIC (ref
))
2473 record_maybe_used_decl (ref
);
2476 if (TREE_CODE (ref
) == CONST_DECL
)
2478 used_types_insert (TREE_TYPE (ref
));
2481 && TREE_CODE (TREE_TYPE (ref
)) == ENUMERAL_TYPE
2482 && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref
)))
2484 warning_at (loc
, OPT_Wc___compat
,
2485 ("enum constant defined in struct or union "
2486 "is not visible in C++"));
2487 inform (DECL_SOURCE_LOCATION (ref
), "enum constant defined here");
2490 ref
= DECL_INITIAL (ref
);
2491 TREE_CONSTANT (ref
) = 1;
2493 else if (current_function_decl
!= 0
2494 && !DECL_FILE_SCOPE_P (current_function_decl
)
2495 && (TREE_CODE (ref
) == VAR_DECL
2496 || TREE_CODE (ref
) == PARM_DECL
2497 || TREE_CODE (ref
) == FUNCTION_DECL
))
2499 tree context
= decl_function_context (ref
);
2501 if (context
!= 0 && context
!= current_function_decl
)
2502 DECL_NONLOCAL (ref
) = 1;
2504 /* C99 6.7.4p3: An inline definition of a function with external
2505 linkage ... shall not contain a reference to an identifier with
2506 internal linkage. */
2507 else if (current_function_decl
!= 0
2508 && DECL_DECLARED_INLINE_P (current_function_decl
)
2509 && DECL_EXTERNAL (current_function_decl
)
2510 && VAR_OR_FUNCTION_DECL_P (ref
)
2511 && (TREE_CODE (ref
) != VAR_DECL
|| TREE_STATIC (ref
))
2512 && ! TREE_PUBLIC (ref
)
2513 && DECL_CONTEXT (ref
) != current_function_decl
)
2514 record_inline_static (loc
, current_function_decl
, ref
,
2520 /* Record details of decls possibly used inside sizeof or typeof. */
2521 struct maybe_used_decl
2525 /* The level seen at (in_sizeof + in_typeof). */
2527 /* The next one at this level or above, or NULL. */
2528 struct maybe_used_decl
*next
;
2531 static struct maybe_used_decl
*maybe_used_decls
;
2533 /* Record that DECL, an undefined static function reference seen
2534 inside sizeof or typeof, might be used if the operand of sizeof is
2535 a VLA type or the operand of typeof is a variably modified
2539 record_maybe_used_decl (tree decl
)
2541 struct maybe_used_decl
*t
= XOBNEW (&parser_obstack
, struct maybe_used_decl
);
2543 t
->level
= in_sizeof
+ in_typeof
;
2544 t
->next
= maybe_used_decls
;
2545 maybe_used_decls
= t
;
2548 /* Pop the stack of decls possibly used inside sizeof or typeof. If
2549 USED is false, just discard them. If it is true, mark them used
2550 (if no longer inside sizeof or typeof) or move them to the next
2551 level up (if still inside sizeof or typeof). */
2554 pop_maybe_used (bool used
)
2556 struct maybe_used_decl
*p
= maybe_used_decls
;
2557 int cur_level
= in_sizeof
+ in_typeof
;
2558 while (p
&& p
->level
> cur_level
)
2563 C_DECL_USED (p
->decl
) = 1;
2565 p
->level
= cur_level
;
2569 if (!used
|| cur_level
== 0)
2570 maybe_used_decls
= p
;
2573 /* Return the result of sizeof applied to EXPR. */
2576 c_expr_sizeof_expr (location_t loc
, struct c_expr expr
)
2579 if (expr
.value
== error_mark_node
)
2581 ret
.value
= error_mark_node
;
2582 ret
.original_code
= ERROR_MARK
;
2583 ret
.original_type
= NULL
;
2584 pop_maybe_used (false);
2588 bool expr_const_operands
= true;
2589 tree folded_expr
= c_fully_fold (expr
.value
, require_constant_value
,
2590 &expr_const_operands
);
2591 ret
.value
= c_sizeof (loc
, TREE_TYPE (folded_expr
));
2592 ret
.original_code
= ERROR_MARK
;
2593 ret
.original_type
= NULL
;
2594 if (c_vla_type_p (TREE_TYPE (folded_expr
)))
2596 /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */
2597 ret
.value
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
.value
),
2598 folded_expr
, ret
.value
);
2599 C_MAYBE_CONST_EXPR_NON_CONST (ret
.value
) = !expr_const_operands
;
2600 SET_EXPR_LOCATION (ret
.value
, loc
);
2602 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr
)));
2607 /* Return the result of sizeof applied to T, a structure for the type
2608 name passed to sizeof (rather than the type itself). LOC is the
2609 location of the original expression. */
2612 c_expr_sizeof_type (location_t loc
, struct c_type_name
*t
)
2616 tree type_expr
= NULL_TREE
;
2617 bool type_expr_const
= true;
2618 type
= groktypename (t
, &type_expr
, &type_expr_const
);
2619 ret
.value
= c_sizeof (loc
, type
);
2620 ret
.original_code
= ERROR_MARK
;
2621 ret
.original_type
= NULL
;
2622 if ((type_expr
|| TREE_CODE (ret
.value
) == INTEGER_CST
)
2623 && c_vla_type_p (type
))
2625 /* If the type is a [*] array, it is a VLA but is represented as
2626 having a size of zero. In such a case we must ensure that
2627 the result of sizeof does not get folded to a constant by
2628 c_fully_fold, because if the size is evaluated the result is
2629 not constant and so constraints on zero or negative size
2630 arrays must not be applied when this sizeof call is inside
2631 another array declarator. */
2633 type_expr
= integer_zero_node
;
2634 ret
.value
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
.value
),
2635 type_expr
, ret
.value
);
2636 C_MAYBE_CONST_EXPR_NON_CONST (ret
.value
) = !type_expr_const
;
2638 pop_maybe_used (type
!= error_mark_node
2639 ? C_TYPE_VARIABLE_SIZE (type
) : false);
2643 /* Build a function call to function FUNCTION with parameters PARAMS.
2644 The function call is at LOC.
2645 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2646 TREE_VALUE of each node is a parameter-expression.
2647 FUNCTION's data type may be a function type or a pointer-to-function. */
2650 build_function_call (location_t loc
, tree function
, tree params
)
2655 vec
= VEC_alloc (tree
, gc
, list_length (params
));
2656 for (; params
; params
= TREE_CHAIN (params
))
2657 VEC_quick_push (tree
, vec
, TREE_VALUE (params
));
2658 ret
= build_function_call_vec (loc
, function
, vec
, NULL
);
2659 VEC_free (tree
, gc
, vec
);
2663 /* Build a function call to function FUNCTION with parameters PARAMS.
2664 ORIGTYPES, if not NULL, is a vector of types; each element is
2665 either NULL or the original type of the corresponding element in
2666 PARAMS. The original type may differ from TREE_TYPE of the
2667 parameter for enums. FUNCTION's data type may be a function type
2668 or pointer-to-function. This function changes the elements of
2672 build_function_call_vec (location_t loc
, tree function
, VEC(tree
,gc
) *params
,
2673 VEC(tree
,gc
) *origtypes
)
2675 tree fntype
, fundecl
= 0;
2676 tree name
= NULL_TREE
, result
;
2682 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2683 STRIP_TYPE_NOPS (function
);
2685 /* Convert anything with function type to a pointer-to-function. */
2686 if (TREE_CODE (function
) == FUNCTION_DECL
)
2688 /* Implement type-directed function overloading for builtins.
2689 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
2690 handle all the type checking. The result is a complete expression
2691 that implements this function call. */
2692 tem
= resolve_overloaded_builtin (loc
, function
, params
);
2696 name
= DECL_NAME (function
);
2699 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
)
2700 function
= function_to_pointer_conversion (loc
, function
);
2702 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2703 expressions, like those used for ObjC messenger dispatches. */
2704 if (!VEC_empty (tree
, params
))
2705 function
= objc_rewrite_function_call (function
,
2706 VEC_index (tree
, params
, 0));
2708 function
= c_fully_fold (function
, false, NULL
);
2710 fntype
= TREE_TYPE (function
);
2712 if (TREE_CODE (fntype
) == ERROR_MARK
)
2713 return error_mark_node
;
2715 if (!(TREE_CODE (fntype
) == POINTER_TYPE
2716 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
2718 error_at (loc
, "called object %qE is not a function", function
);
2719 return error_mark_node
;
2722 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
2723 current_function_returns_abnormally
= 1;
2725 /* fntype now gets the type of function pointed to. */
2726 fntype
= TREE_TYPE (fntype
);
2728 /* Convert the parameters to the types declared in the
2729 function prototype, or apply default promotions. */
2731 nargs
= convert_arguments (TYPE_ARG_TYPES (fntype
), params
, origtypes
,
2734 return error_mark_node
;
2736 /* Check that the function is called through a compatible prototype.
2737 If it is not, replace the call by a trap, wrapped up in a compound
2738 expression if necessary. This has the nice side-effect to prevent
2739 the tree-inliner from generating invalid assignment trees which may
2740 blow up in the RTL expander later. */
2741 if (CONVERT_EXPR_P (function
)
2742 && TREE_CODE (tem
= TREE_OPERAND (function
, 0)) == ADDR_EXPR
2743 && TREE_CODE (tem
= TREE_OPERAND (tem
, 0)) == FUNCTION_DECL
2744 && !comptypes (fntype
, TREE_TYPE (tem
)))
2746 tree return_type
= TREE_TYPE (fntype
);
2747 tree trap
= build_function_call (loc
, built_in_decls
[BUILT_IN_TRAP
],
2751 /* This situation leads to run-time undefined behavior. We can't,
2752 therefore, simply error unless we can prove that all possible
2753 executions of the program must execute the code. */
2754 if (warning_at (loc
, 0, "function called through a non-compatible type"))
2755 /* We can, however, treat "undefined" any way we please.
2756 Call abort to encourage the user to fix the program. */
2757 inform (loc
, "if this code is reached, the program will abort");
2758 /* Before the abort, allow the function arguments to exit or
2760 for (i
= 0; i
< nargs
; i
++)
2761 trap
= build2 (COMPOUND_EXPR
, void_type_node
,
2762 VEC_index (tree
, params
, i
), trap
);
2764 if (VOID_TYPE_P (return_type
))
2766 if (TYPE_QUALS (return_type
) != TYPE_UNQUALIFIED
)
2768 "function with qualified void return type called");
2775 if (AGGREGATE_TYPE_P (return_type
))
2776 rhs
= build_compound_literal (loc
, return_type
,
2777 build_constructor (return_type
, 0),
2780 rhs
= fold_convert_loc (loc
, return_type
, integer_zero_node
);
2782 return require_complete_type (build2 (COMPOUND_EXPR
, return_type
,
2787 argarray
= VEC_address (tree
, params
);
2789 /* Check that arguments to builtin functions match the expectations. */
2791 && DECL_BUILT_IN (fundecl
)
2792 && DECL_BUILT_IN_CLASS (fundecl
) == BUILT_IN_NORMAL
2793 && !check_builtin_function_arguments (fundecl
, nargs
, argarray
))
2794 return error_mark_node
;
2796 /* Check that the arguments to the function are valid. */
2797 check_function_arguments (TYPE_ATTRIBUTES (fntype
), nargs
, argarray
,
2798 TYPE_ARG_TYPES (fntype
));
2800 if (name
!= NULL_TREE
2801 && !strncmp (IDENTIFIER_POINTER (name
), "__builtin_", 10))
2803 if (require_constant_value
)
2805 fold_build_call_array_initializer_loc (loc
, TREE_TYPE (fntype
),
2806 function
, nargs
, argarray
);
2808 result
= fold_build_call_array_loc (loc
, TREE_TYPE (fntype
),
2809 function
, nargs
, argarray
);
2810 if (TREE_CODE (result
) == NOP_EXPR
2811 && TREE_CODE (TREE_OPERAND (result
, 0)) == INTEGER_CST
)
2812 STRIP_TYPE_NOPS (result
);
2815 result
= build_call_array_loc (loc
, TREE_TYPE (fntype
),
2816 function
, nargs
, argarray
);
2818 if (VOID_TYPE_P (TREE_TYPE (result
)))
2820 if (TYPE_QUALS (TREE_TYPE (result
)) != TYPE_UNQUALIFIED
)
2822 "function with qualified void return type called");
2825 return require_complete_type (result
);
2828 /* Convert the argument expressions in the vector VALUES
2829 to the types in the list TYPELIST.
2831 If TYPELIST is exhausted, or when an element has NULL as its type,
2832 perform the default conversions.
2834 ORIGTYPES is the original types of the expressions in VALUES. This
2835 holds the type of enum values which have been converted to integral
2836 types. It may be NULL.
2838 FUNCTION is a tree for the called function. It is used only for
2839 error messages, where it is formatted with %qE.
2841 This is also where warnings about wrong number of args are generated.
2843 Returns the actual number of arguments processed (which may be less
2844 than the length of VALUES in some error situations), or -1 on
2848 convert_arguments (tree typelist
, VEC(tree
,gc
) *values
,
2849 VEC(tree
,gc
) *origtypes
, tree function
, tree fundecl
)
2852 unsigned int parmnum
;
2853 bool error_args
= false;
2854 const bool type_generic
= fundecl
2855 && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl
)));
2856 bool type_generic_remove_excess_precision
= false;
2859 /* Change pointer to function to the function itself for
2861 if (TREE_CODE (function
) == ADDR_EXPR
2862 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
2863 function
= TREE_OPERAND (function
, 0);
2865 /* Handle an ObjC selector specially for diagnostics. */
2866 selector
= objc_message_selector ();
2868 /* For type-generic built-in functions, determine whether excess
2869 precision should be removed (classification) or not
2872 && DECL_BUILT_IN (fundecl
)
2873 && DECL_BUILT_IN_CLASS (fundecl
) == BUILT_IN_NORMAL
)
2875 switch (DECL_FUNCTION_CODE (fundecl
))
2877 case BUILT_IN_ISFINITE
:
2878 case BUILT_IN_ISINF
:
2879 case BUILT_IN_ISINF_SIGN
:
2880 case BUILT_IN_ISNAN
:
2881 case BUILT_IN_ISNORMAL
:
2882 case BUILT_IN_FPCLASSIFY
:
2883 type_generic_remove_excess_precision
= true;
2887 type_generic_remove_excess_precision
= false;
2892 /* Scan the given expressions and types, producing individual
2893 converted arguments. */
2895 for (typetail
= typelist
, parmnum
= 0;
2896 VEC_iterate (tree
, values
, parmnum
, val
);
2899 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
2900 tree valtype
= TREE_TYPE (val
);
2901 tree rname
= function
;
2902 int argnum
= parmnum
+ 1;
2903 const char *invalid_func_diag
;
2904 bool excess_precision
= false;
2908 if (type
== void_type_node
)
2910 error_at (input_location
,
2911 "too many arguments to function %qE", function
);
2912 if (fundecl
&& !DECL_BUILT_IN (fundecl
))
2913 inform (DECL_SOURCE_LOCATION (fundecl
), "declared here");
2917 if (selector
&& argnum
> 2)
2923 npc
= null_pointer_constant_p (val
);
2925 /* If there is excess precision and a prototype, convert once to
2926 the required type rather than converting via the semantic
2927 type. Likewise without a prototype a float value represented
2928 as long double should be converted once to double. But for
2929 type-generic classification functions excess precision must
2931 if (TREE_CODE (val
) == EXCESS_PRECISION_EXPR
2932 && (type
|| !type_generic
|| !type_generic_remove_excess_precision
))
2934 val
= TREE_OPERAND (val
, 0);
2935 excess_precision
= true;
2937 val
= c_fully_fold (val
, false, NULL
);
2938 STRIP_TYPE_NOPS (val
);
2940 val
= require_complete_type (val
);
2944 /* Formal parm type is specified by a function prototype. */
2946 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
2948 error ("type of formal parameter %d is incomplete", parmnum
+ 1);
2955 /* Optionally warn about conversions that
2956 differ from the default conversions. */
2957 if (warn_traditional_conversion
|| warn_traditional
)
2959 unsigned int formal_prec
= TYPE_PRECISION (type
);
2961 if (INTEGRAL_TYPE_P (type
)
2962 && TREE_CODE (valtype
) == REAL_TYPE
)
2963 warning (0, "passing argument %d of %qE as integer "
2964 "rather than floating due to prototype",
2966 if (INTEGRAL_TYPE_P (type
)
2967 && TREE_CODE (valtype
) == COMPLEX_TYPE
)
2968 warning (0, "passing argument %d of %qE as integer "
2969 "rather than complex due to prototype",
2971 else if (TREE_CODE (type
) == COMPLEX_TYPE
2972 && TREE_CODE (valtype
) == REAL_TYPE
)
2973 warning (0, "passing argument %d of %qE as complex "
2974 "rather than floating due to prototype",
2976 else if (TREE_CODE (type
) == REAL_TYPE
2977 && INTEGRAL_TYPE_P (valtype
))
2978 warning (0, "passing argument %d of %qE as floating "
2979 "rather than integer due to prototype",
2981 else if (TREE_CODE (type
) == COMPLEX_TYPE
2982 && INTEGRAL_TYPE_P (valtype
))
2983 warning (0, "passing argument %d of %qE as complex "
2984 "rather than integer due to prototype",
2986 else if (TREE_CODE (type
) == REAL_TYPE
2987 && TREE_CODE (valtype
) == COMPLEX_TYPE
)
2988 warning (0, "passing argument %d of %qE as floating "
2989 "rather than complex due to prototype",
2991 /* ??? At some point, messages should be written about
2992 conversions between complex types, but that's too messy
2994 else if (TREE_CODE (type
) == REAL_TYPE
2995 && TREE_CODE (valtype
) == REAL_TYPE
)
2997 /* Warn if any argument is passed as `float',
2998 since without a prototype it would be `double'. */
2999 if (formal_prec
== TYPE_PRECISION (float_type_node
)
3000 && type
!= dfloat32_type_node
)
3001 warning (0, "passing argument %d of %qE as %<float%> "
3002 "rather than %<double%> due to prototype",
3005 /* Warn if mismatch between argument and prototype
3006 for decimal float types. Warn of conversions with
3007 binary float types and of precision narrowing due to
3009 else if (type
!= valtype
3010 && (type
== dfloat32_type_node
3011 || type
== dfloat64_type_node
3012 || type
== dfloat128_type_node
3013 || valtype
== dfloat32_type_node
3014 || valtype
== dfloat64_type_node
3015 || valtype
== dfloat128_type_node
)
3017 <= TYPE_PRECISION (valtype
)
3018 || (type
== dfloat128_type_node
3020 != dfloat64_type_node
3022 != dfloat32_type_node
)))
3023 || (type
== dfloat64_type_node
3025 != dfloat32_type_node
))))
3026 warning (0, "passing argument %d of %qE as %qT "
3027 "rather than %qT due to prototype",
3028 argnum
, rname
, type
, valtype
);
3031 /* Detect integer changing in width or signedness.
3032 These warnings are only activated with
3033 -Wtraditional-conversion, not with -Wtraditional. */
3034 else if (warn_traditional_conversion
&& INTEGRAL_TYPE_P (type
)
3035 && INTEGRAL_TYPE_P (valtype
))
3037 tree would_have_been
= default_conversion (val
);
3038 tree type1
= TREE_TYPE (would_have_been
);
3040 if (TREE_CODE (type
) == ENUMERAL_TYPE
3041 && (TYPE_MAIN_VARIANT (type
)
3042 == TYPE_MAIN_VARIANT (valtype
)))
3043 /* No warning if function asks for enum
3044 and the actual arg is that enum type. */
3046 else if (formal_prec
!= TYPE_PRECISION (type1
))
3047 warning (OPT_Wtraditional_conversion
,
3048 "passing argument %d of %qE "
3049 "with different width due to prototype",
3051 else if (TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (type1
))
3053 /* Don't complain if the formal parameter type
3054 is an enum, because we can't tell now whether
3055 the value was an enum--even the same enum. */
3056 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
3058 else if (TREE_CODE (val
) == INTEGER_CST
3059 && int_fits_type_p (val
, type
))
3060 /* Change in signedness doesn't matter
3061 if a constant value is unaffected. */
3063 /* If the value is extended from a narrower
3064 unsigned type, it doesn't matter whether we
3065 pass it as signed or unsigned; the value
3066 certainly is the same either way. */
3067 else if (TYPE_PRECISION (valtype
) < TYPE_PRECISION (type
)
3068 && TYPE_UNSIGNED (valtype
))
3070 else if (TYPE_UNSIGNED (type
))
3071 warning (OPT_Wtraditional_conversion
,
3072 "passing argument %d of %qE "
3073 "as unsigned due to prototype",
3076 warning (OPT_Wtraditional_conversion
,
3077 "passing argument %d of %qE "
3078 "as signed due to prototype", argnum
, rname
);
3082 /* Possibly restore an EXCESS_PRECISION_EXPR for the
3083 sake of better warnings from convert_and_check. */
3084 if (excess_precision
)
3085 val
= build1 (EXCESS_PRECISION_EXPR
, valtype
, val
);
3086 origtype
= (origtypes
== NULL
3088 : VEC_index (tree
, origtypes
, parmnum
));
3089 parmval
= convert_for_assignment (input_location
, type
, val
,
3090 origtype
, ic_argpass
, npc
,
3094 if (targetm
.calls
.promote_prototypes (fundecl
? TREE_TYPE (fundecl
) : 0)
3095 && INTEGRAL_TYPE_P (type
)
3096 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
3097 parmval
= default_conversion (parmval
);
3100 else if (TREE_CODE (valtype
) == REAL_TYPE
3101 && (TYPE_PRECISION (valtype
)
3102 < TYPE_PRECISION (double_type_node
))
3103 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype
)))
3108 /* Convert `float' to `double'. */
3109 parmval
= convert (double_type_node
, val
);
3111 else if (excess_precision
&& !type_generic
)
3112 /* A "double" argument with excess precision being passed
3113 without a prototype or in variable arguments. */
3114 parmval
= convert (valtype
, val
);
3115 else if ((invalid_func_diag
=
3116 targetm
.calls
.invalid_arg_for_unprototyped_fn (typelist
, fundecl
, val
)))
3118 error (invalid_func_diag
);
3122 /* Convert `short' and `char' to full-size `int'. */
3123 parmval
= default_conversion (val
);
3125 VEC_replace (tree
, values
, parmnum
, parmval
);
3126 if (parmval
== error_mark_node
)
3130 typetail
= TREE_CHAIN (typetail
);
3133 gcc_assert (parmnum
== VEC_length (tree
, values
));
3135 if (typetail
!= 0 && TREE_VALUE (typetail
) != void_type_node
)
3137 error_at (input_location
,
3138 "too few arguments to function %qE", function
);
3139 if (fundecl
&& !DECL_BUILT_IN (fundecl
))
3140 inform (DECL_SOURCE_LOCATION (fundecl
), "declared here");
3144 return error_args
? -1 : (int) parmnum
;
3147 /* This is the entry point used by the parser to build unary operators
3148 in the input. CODE, a tree_code, specifies the unary operator, and
3149 ARG is the operand. For unary plus, the C parser currently uses
3150 CONVERT_EXPR for code.
3152 LOC is the location to use for the tree generated.
3156 parser_build_unary_op (location_t loc
, enum tree_code code
, struct c_expr arg
)
3158 struct c_expr result
;
3160 result
.value
= build_unary_op (loc
, code
, arg
.value
, 0);
3161 result
.original_code
= code
;
3162 result
.original_type
= NULL
;
3164 if (TREE_OVERFLOW_P (result
.value
) && !TREE_OVERFLOW_P (arg
.value
))
3165 overflow_warning (loc
, result
.value
);
3170 /* This is the entry point used by the parser to build binary operators
3171 in the input. CODE, a tree_code, specifies the binary operator, and
3172 ARG1 and ARG2 are the operands. In addition to constructing the
3173 expression, we check for operands that were written with other binary
3174 operators in a way that is likely to confuse the user.
3176 LOCATION is the location of the binary operator. */
3179 parser_build_binary_op (location_t location
, enum tree_code code
,
3180 struct c_expr arg1
, struct c_expr arg2
)
3182 struct c_expr result
;
3184 enum tree_code code1
= arg1
.original_code
;
3185 enum tree_code code2
= arg2
.original_code
;
3186 tree type1
= (arg1
.original_type
3187 ? arg1
.original_type
3188 : TREE_TYPE (arg1
.value
));
3189 tree type2
= (arg2
.original_type
3190 ? arg2
.original_type
3191 : TREE_TYPE (arg2
.value
));
3193 result
.value
= build_binary_op (location
, code
,
3194 arg1
.value
, arg2
.value
, 1);
3195 result
.original_code
= code
;
3196 result
.original_type
= NULL
;
3198 if (TREE_CODE (result
.value
) == ERROR_MARK
)
3201 if (location
!= UNKNOWN_LOCATION
)
3202 protected_set_expr_location (result
.value
, location
);
3204 /* Check for cases such as x+y<<z which users are likely
3206 if (warn_parentheses
)
3207 warn_about_parentheses (code
, code1
, arg1
.value
, code2
, arg2
.value
);
3209 if (warn_logical_op
)
3210 warn_logical_operator (input_location
, code
, TREE_TYPE (result
.value
),
3211 code1
, arg1
.value
, code2
, arg2
.value
);
3213 /* Warn about comparisons against string literals, with the exception
3214 of testing for equality or inequality of a string literal with NULL. */
3215 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
3217 if ((code1
== STRING_CST
&& !integer_zerop (arg2
.value
))
3218 || (code2
== STRING_CST
&& !integer_zerop (arg1
.value
)))
3219 warning_at (location
, OPT_Waddress
,
3220 "comparison with string literal results in unspecified behavior");
3222 else if (TREE_CODE_CLASS (code
) == tcc_comparison
3223 && (code1
== STRING_CST
|| code2
== STRING_CST
))
3224 warning_at (location
, OPT_Waddress
,
3225 "comparison with string literal results in unspecified behavior");
3227 if (TREE_OVERFLOW_P (result
.value
)
3228 && !TREE_OVERFLOW_P (arg1
.value
)
3229 && !TREE_OVERFLOW_P (arg2
.value
))
3230 overflow_warning (location
, result
.value
);
3232 /* Warn about comparisons of different enum types. */
3233 if (warn_enum_compare
3234 && TREE_CODE_CLASS (code
) == tcc_comparison
3235 && TREE_CODE (type1
) == ENUMERAL_TYPE
3236 && TREE_CODE (type2
) == ENUMERAL_TYPE
3237 && TYPE_MAIN_VARIANT (type1
) != TYPE_MAIN_VARIANT (type2
))
3238 warning_at (location
, OPT_Wenum_compare
,
3239 "comparison between %qT and %qT",
3245 /* Return a tree for the difference of pointers OP0 and OP1.
3246 The resulting tree has type int. */
3249 pointer_diff (location_t loc
, tree op0
, tree op1
)
3251 tree restype
= ptrdiff_type_node
;
3252 tree result
, inttype
;
3254 addr_space_t as0
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0
)));
3255 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1
)));
3256 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
3257 tree con0
, con1
, lit0
, lit1
;
3258 tree orig_op1
= op1
;
3260 /* If the operands point into different address spaces, we need to
3261 explicitly convert them to pointers into the common address space
3262 before we can subtract the numerical address values. */
3265 addr_space_t as_common
;
3268 /* Determine the common superset address space. This is guaranteed
3269 to exist because the caller verified that comp_target_types
3270 returned non-zero. */
3271 if (!addr_space_superset (as0
, as1
, &as_common
))
3274 common_type
= common_pointer_type (TREE_TYPE (op0
), TREE_TYPE (op1
));
3275 op0
= convert (common_type
, op0
);
3276 op1
= convert (common_type
, op1
);
3279 /* Determine integer type to perform computations in. This will usually
3280 be the same as the result type (ptrdiff_t), but may need to be a wider
3281 type if pointers for the address space are wider than ptrdiff_t. */
3282 if (TYPE_PRECISION (restype
) < TYPE_PRECISION (TREE_TYPE (op0
)))
3283 inttype
= lang_hooks
.types
.type_for_size
3284 (TYPE_PRECISION (TREE_TYPE (op0
)), 0);
3289 if (TREE_CODE (target_type
) == VOID_TYPE
)
3290 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3291 "pointer of type %<void *%> used in subtraction");
3292 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3293 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3294 "pointer to a function used in subtraction");
3296 /* If the conversion to ptrdiff_type does anything like widening or
3297 converting a partial to an integral mode, we get a convert_expression
3298 that is in the way to do any simplifications.
3299 (fold-const.c doesn't know that the extra bits won't be needed.
3300 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
3301 different mode in place.)
3302 So first try to find a common term here 'by hand'; we want to cover
3303 at least the cases that occur in legal static initializers. */
3304 if (CONVERT_EXPR_P (op0
)
3305 && (TYPE_PRECISION (TREE_TYPE (op0
))
3306 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))))
3307 con0
= TREE_OPERAND (op0
, 0);
3310 if (CONVERT_EXPR_P (op1
)
3311 && (TYPE_PRECISION (TREE_TYPE (op1
))
3312 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0)))))
3313 con1
= TREE_OPERAND (op1
, 0);
3317 if (TREE_CODE (con0
) == PLUS_EXPR
)
3319 lit0
= TREE_OPERAND (con0
, 1);
3320 con0
= TREE_OPERAND (con0
, 0);
3323 lit0
= integer_zero_node
;
3325 if (TREE_CODE (con1
) == PLUS_EXPR
)
3327 lit1
= TREE_OPERAND (con1
, 1);
3328 con1
= TREE_OPERAND (con1
, 0);
3331 lit1
= integer_zero_node
;
3333 if (operand_equal_p (con0
, con1
, 0))
3340 /* First do the subtraction as integers;
3341 then drop through to build the divide operator.
3342 Do not do default conversions on the minus operator
3343 in case restype is a short type. */
3345 op0
= build_binary_op (loc
,
3346 MINUS_EXPR
, convert (inttype
, op0
),
3347 convert (inttype
, op1
), 0);
3348 /* This generates an error if op1 is pointer to incomplete type. */
3349 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1
))))
3350 error_at (loc
, "arithmetic on pointer to an incomplete type");
3352 /* This generates an error if op0 is pointer to incomplete type. */
3353 op1
= c_size_in_bytes (target_type
);
3355 /* Divide by the size, in easiest possible way. */
3356 result
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, inttype
,
3357 op0
, convert (inttype
, op1
));
3359 /* Convert to final result type if necessary. */
3360 return convert (restype
, result
);
3363 /* Construct and perhaps optimize a tree representation
3364 for a unary operation. CODE, a tree_code, specifies the operation
3365 and XARG is the operand.
3366 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
3367 the default promotions (such as from short to int).
3368 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
3369 allows non-lvalues; this is only used to handle conversion of non-lvalue
3370 arrays to pointers in C99.
3372 LOCATION is the location of the operator. */
3375 build_unary_op (location_t location
,
3376 enum tree_code code
, tree xarg
, int flag
)
3378 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3381 enum tree_code typecode
;
3383 tree ret
= error_mark_node
;
3384 tree eptype
= NULL_TREE
;
3385 int noconvert
= flag
;
3386 const char *invalid_op_diag
;
3389 int_operands
= EXPR_INT_CONST_OPERANDS (xarg
);
3391 arg
= remove_c_maybe_const_expr (arg
);
3393 if (code
!= ADDR_EXPR
)
3394 arg
= require_complete_type (arg
);
3396 typecode
= TREE_CODE (TREE_TYPE (arg
));
3397 if (typecode
== ERROR_MARK
)
3398 return error_mark_node
;
3399 if (typecode
== ENUMERAL_TYPE
|| typecode
== BOOLEAN_TYPE
)
3400 typecode
= INTEGER_TYPE
;
3402 if ((invalid_op_diag
3403 = targetm
.invalid_unary_op (code
, TREE_TYPE (xarg
))))
3405 error_at (location
, invalid_op_diag
);
3406 return error_mark_node
;
3409 if (TREE_CODE (arg
) == EXCESS_PRECISION_EXPR
)
3411 eptype
= TREE_TYPE (arg
);
3412 arg
= TREE_OPERAND (arg
, 0);
3418 /* This is used for unary plus, because a CONVERT_EXPR
3419 is enough to prevent anybody from looking inside for
3420 associativity, but won't generate any code. */
3421 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
3422 || typecode
== FIXED_POINT_TYPE
|| typecode
== COMPLEX_TYPE
3423 || typecode
== VECTOR_TYPE
))
3425 error_at (location
, "wrong type argument to unary plus");
3426 return error_mark_node
;
3428 else if (!noconvert
)
3429 arg
= default_conversion (arg
);
3430 arg
= non_lvalue_loc (location
, arg
);
3434 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
3435 || typecode
== FIXED_POINT_TYPE
|| typecode
== COMPLEX_TYPE
3436 || typecode
== VECTOR_TYPE
))
3438 error_at (location
, "wrong type argument to unary minus");
3439 return error_mark_node
;
3441 else if (!noconvert
)
3442 arg
= default_conversion (arg
);
3446 /* ~ works on integer types and non float vectors. */
3447 if (typecode
== INTEGER_TYPE
3448 || (typecode
== VECTOR_TYPE
3449 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg
))))
3452 arg
= default_conversion (arg
);
3454 else if (typecode
== COMPLEX_TYPE
)
3457 pedwarn (location
, OPT_pedantic
,
3458 "ISO C does not support %<~%> for complex conjugation");
3460 arg
= default_conversion (arg
);
3464 error_at (location
, "wrong type argument to bit-complement");
3465 return error_mark_node
;
3470 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3472 error_at (location
, "wrong type argument to abs");
3473 return error_mark_node
;
3475 else if (!noconvert
)
3476 arg
= default_conversion (arg
);
3480 /* Conjugating a real value is a no-op, but allow it anyway. */
3481 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
3482 || typecode
== COMPLEX_TYPE
))
3484 error_at (location
, "wrong type argument to conjugation");
3485 return error_mark_node
;
3487 else if (!noconvert
)
3488 arg
= default_conversion (arg
);
3491 case TRUTH_NOT_EXPR
:
3492 if (typecode
!= INTEGER_TYPE
&& typecode
!= FIXED_POINT_TYPE
3493 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
3494 && typecode
!= COMPLEX_TYPE
)
3497 "wrong type argument to unary exclamation mark");
3498 return error_mark_node
;
3500 arg
= c_objc_common_truthvalue_conversion (location
, arg
);
3501 ret
= invert_truthvalue_loc (location
, arg
);
3502 /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
3503 if (EXPR_P (ret
) && EXPR_HAS_LOCATION (ret
))
3504 location
= EXPR_LOCATION (ret
);
3505 goto return_build_unary_op
;
3508 if (TREE_CODE (arg
) == COMPLEX_CST
)
3509 ret
= TREE_REALPART (arg
);
3510 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
3511 ret
= fold_build1_loc (location
,
3512 REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
);
3515 if (eptype
&& TREE_CODE (eptype
) == COMPLEX_TYPE
)
3516 eptype
= TREE_TYPE (eptype
);
3517 goto return_build_unary_op
;
3520 if (TREE_CODE (arg
) == COMPLEX_CST
)
3521 ret
= TREE_IMAGPART (arg
);
3522 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
3523 ret
= fold_build1_loc (location
,
3524 IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
);
3526 ret
= omit_one_operand_loc (location
, TREE_TYPE (arg
),
3527 integer_zero_node
, arg
);
3528 if (eptype
&& TREE_CODE (eptype
) == COMPLEX_TYPE
)
3529 eptype
= TREE_TYPE (eptype
);
3530 goto return_build_unary_op
;
3532 case PREINCREMENT_EXPR
:
3533 case POSTINCREMENT_EXPR
:
3534 case PREDECREMENT_EXPR
:
3535 case POSTDECREMENT_EXPR
:
3537 if (TREE_CODE (arg
) == C_MAYBE_CONST_EXPR
)
3539 tree inner
= build_unary_op (location
, code
,
3540 C_MAYBE_CONST_EXPR_EXPR (arg
), flag
);
3541 if (inner
== error_mark_node
)
3542 return error_mark_node
;
3543 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
3544 C_MAYBE_CONST_EXPR_PRE (arg
), inner
);
3545 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg
));
3546 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = 1;
3547 goto return_build_unary_op
;
3550 /* Complain about anything that is not a true lvalue. */
3551 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
3552 || code
== POSTINCREMENT_EXPR
)
3555 return error_mark_node
;
3557 if (warn_cxx_compat
&& TREE_CODE (TREE_TYPE (arg
)) == ENUMERAL_TYPE
)
3559 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3560 warning_at (location
, OPT_Wc___compat
,
3561 "increment of enumeration value is invalid in C++");
3563 warning_at (location
, OPT_Wc___compat
,
3564 "decrement of enumeration value is invalid in C++");
3567 /* Ensure the argument is fully folded inside any SAVE_EXPR. */
3568 arg
= c_fully_fold (arg
, false, NULL
);
3570 /* Increment or decrement the real part of the value,
3571 and don't change the imaginary part. */
3572 if (typecode
== COMPLEX_TYPE
)
3576 pedwarn (location
, OPT_pedantic
,
3577 "ISO C does not support %<++%> and %<--%> on complex types");
3579 arg
= stabilize_reference (arg
);
3580 real
= build_unary_op (EXPR_LOCATION (arg
), REALPART_EXPR
, arg
, 1);
3581 imag
= build_unary_op (EXPR_LOCATION (arg
), IMAGPART_EXPR
, arg
, 1);
3582 real
= build_unary_op (EXPR_LOCATION (arg
), code
, real
, 1);
3583 if (real
== error_mark_node
|| imag
== error_mark_node
)
3584 return error_mark_node
;
3585 ret
= build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
3587 goto return_build_unary_op
;
3590 /* Report invalid types. */
3592 if (typecode
!= POINTER_TYPE
&& typecode
!= FIXED_POINT_TYPE
3593 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
3595 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3596 error_at (location
, "wrong type argument to increment");
3598 error_at (location
, "wrong type argument to decrement");
3600 return error_mark_node
;
3606 argtype
= TREE_TYPE (arg
);
3608 /* Compute the increment. */
3610 if (typecode
== POINTER_TYPE
)
3612 /* If pointer target is an undefined struct,
3613 we just cannot know how to do the arithmetic. */
3614 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype
)))
3616 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3618 "increment of pointer to unknown structure");
3621 "decrement of pointer to unknown structure");
3623 else if (TREE_CODE (TREE_TYPE (argtype
)) == FUNCTION_TYPE
3624 || TREE_CODE (TREE_TYPE (argtype
)) == VOID_TYPE
)
3626 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3627 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3628 "wrong type argument to increment");
3630 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3631 "wrong type argument to decrement");
3634 inc
= c_size_in_bytes (TREE_TYPE (argtype
));
3635 inc
= fold_convert_loc (location
, sizetype
, inc
);
3637 else if (FRACT_MODE_P (TYPE_MODE (argtype
)))
3639 /* For signed fract types, we invert ++ to -- or
3640 -- to ++, and change inc from 1 to -1, because
3641 it is not possible to represent 1 in signed fract constants.
3642 For unsigned fract types, the result always overflows and
3643 we get an undefined (original) or the maximum value. */
3644 if (code
== PREINCREMENT_EXPR
)
3645 code
= PREDECREMENT_EXPR
;
3646 else if (code
== PREDECREMENT_EXPR
)
3647 code
= PREINCREMENT_EXPR
;
3648 else if (code
== POSTINCREMENT_EXPR
)
3649 code
= POSTDECREMENT_EXPR
;
3650 else /* code == POSTDECREMENT_EXPR */
3651 code
= POSTINCREMENT_EXPR
;
3653 inc
= integer_minus_one_node
;
3654 inc
= convert (argtype
, inc
);
3658 inc
= integer_one_node
;
3659 inc
= convert (argtype
, inc
);
3662 /* Report a read-only lvalue. */
3663 if (TYPE_READONLY (argtype
))
3665 readonly_error (arg
,
3666 ((code
== PREINCREMENT_EXPR
3667 || code
== POSTINCREMENT_EXPR
)
3668 ? lv_increment
: lv_decrement
));
3669 return error_mark_node
;
3671 else if (TREE_READONLY (arg
))
3672 readonly_warning (arg
,
3673 ((code
== PREINCREMENT_EXPR
3674 || code
== POSTINCREMENT_EXPR
)
3675 ? lv_increment
: lv_decrement
));
3677 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3678 val
= boolean_increment (code
, arg
);
3680 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
3681 TREE_SIDE_EFFECTS (val
) = 1;
3682 if (TREE_CODE (val
) != code
)
3683 TREE_NO_WARNING (val
) = 1;
3685 goto return_build_unary_op
;
3689 /* Note that this operation never does default_conversion. */
3691 /* The operand of unary '&' must be an lvalue (which excludes
3692 expressions of type void), or, in C99, the result of a [] or
3693 unary '*' operator. */
3694 if (VOID_TYPE_P (TREE_TYPE (arg
))
3695 && TYPE_QUALS (TREE_TYPE (arg
)) == TYPE_UNQUALIFIED
3696 && (TREE_CODE (arg
) != INDIRECT_REF
3698 pedwarn (location
, 0, "taking address of expression of type %<void%>");
3700 /* Let &* cancel out to simplify resulting code. */
3701 if (TREE_CODE (arg
) == INDIRECT_REF
)
3703 /* Don't let this be an lvalue. */
3704 if (lvalue_p (TREE_OPERAND (arg
, 0)))
3705 return non_lvalue_loc (location
, TREE_OPERAND (arg
, 0));
3706 ret
= TREE_OPERAND (arg
, 0);
3707 goto return_build_unary_op
;
3710 /* For &x[y], return x+y */
3711 if (TREE_CODE (arg
) == ARRAY_REF
)
3713 tree op0
= TREE_OPERAND (arg
, 0);
3714 if (!c_mark_addressable (op0
))
3715 return error_mark_node
;
3716 return build_binary_op (location
, PLUS_EXPR
,
3717 (TREE_CODE (TREE_TYPE (op0
)) == ARRAY_TYPE
3718 ? array_to_pointer_conversion (location
,
3721 TREE_OPERAND (arg
, 1), 1);
3724 /* Anything not already handled and not a true memory reference
3725 or a non-lvalue array is an error. */
3726 else if (typecode
!= FUNCTION_TYPE
&& !flag
3727 && !lvalue_or_else (arg
, lv_addressof
))
3728 return error_mark_node
;
3730 /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
3732 if (TREE_CODE (arg
) == C_MAYBE_CONST_EXPR
)
3734 tree inner
= build_unary_op (location
, code
,
3735 C_MAYBE_CONST_EXPR_EXPR (arg
), flag
);
3736 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
3737 C_MAYBE_CONST_EXPR_PRE (arg
), inner
);
3738 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg
));
3739 C_MAYBE_CONST_EXPR_NON_CONST (ret
)
3740 = C_MAYBE_CONST_EXPR_NON_CONST (arg
);
3741 goto return_build_unary_op
;
3744 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3745 argtype
= TREE_TYPE (arg
);
3747 /* If the lvalue is const or volatile, merge that into the type
3748 to which the address will point. This should only be needed
3749 for function types. */
3750 if ((DECL_P (arg
) || REFERENCE_CLASS_P (arg
))
3751 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
)))
3753 int orig_quals
= TYPE_QUALS (strip_array_types (argtype
));
3754 int quals
= orig_quals
;
3756 if (TREE_READONLY (arg
))
3757 quals
|= TYPE_QUAL_CONST
;
3758 if (TREE_THIS_VOLATILE (arg
))
3759 quals
|= TYPE_QUAL_VOLATILE
;
3761 gcc_assert (quals
== orig_quals
3762 || TREE_CODE (argtype
) == FUNCTION_TYPE
);
3764 argtype
= c_build_qualified_type (argtype
, quals
);
3767 if (!c_mark_addressable (arg
))
3768 return error_mark_node
;
3770 gcc_assert (TREE_CODE (arg
) != COMPONENT_REF
3771 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)));
3773 argtype
= build_pointer_type (argtype
);
3775 /* ??? Cope with user tricks that amount to offsetof. Delete this
3776 when we have proper support for integer constant expressions. */
3777 val
= get_base_address (arg
);
3778 if (val
&& TREE_CODE (val
) == INDIRECT_REF
3779 && TREE_CONSTANT (TREE_OPERAND (val
, 0)))
3781 tree op0
= fold_convert_loc (location
, sizetype
,
3782 fold_offsetof (arg
, val
)), op1
;
3784 op1
= fold_convert_loc (location
, argtype
, TREE_OPERAND (val
, 0));
3785 ret
= fold_build2_loc (location
, POINTER_PLUS_EXPR
, argtype
, op1
, op0
);
3786 goto return_build_unary_op
;
3789 val
= build1 (ADDR_EXPR
, argtype
, arg
);
3792 goto return_build_unary_op
;
3799 argtype
= TREE_TYPE (arg
);
3800 if (TREE_CODE (arg
) == INTEGER_CST
)
3801 ret
= (require_constant_value
3802 ? fold_build1_initializer_loc (location
, code
, argtype
, arg
)
3803 : fold_build1_loc (location
, code
, argtype
, arg
));
3805 ret
= build1 (code
, argtype
, arg
);
3806 return_build_unary_op
:
3807 gcc_assert (ret
!= error_mark_node
);
3808 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
)
3809 && !(TREE_CODE (xarg
) == INTEGER_CST
&& !TREE_OVERFLOW (xarg
)))
3810 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
3811 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
)
3812 ret
= note_integer_operands (ret
);
3814 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
3815 protected_set_expr_location (ret
, location
);
3819 /* Return nonzero if REF is an lvalue valid for this language.
3820 Lvalues can be assigned, unless their type has TYPE_READONLY.
3821 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
3824 lvalue_p (const_tree ref
)
3826 const enum tree_code code
= TREE_CODE (ref
);
3833 return lvalue_p (TREE_OPERAND (ref
, 0));
3835 case C_MAYBE_CONST_EXPR
:
3836 return lvalue_p (TREE_OPERAND (ref
, 1));
3838 case COMPOUND_LITERAL_EXPR
:
3848 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
3849 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
3852 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
3859 /* Give an error for storing in something that is 'const'. */
3862 readonly_error (tree arg
, enum lvalue_use use
)
3864 gcc_assert (use
== lv_assign
|| use
== lv_increment
|| use
== lv_decrement
3866 /* Using this macro rather than (for example) arrays of messages
3867 ensures that all the format strings are checked at compile
3869 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
3870 : (use == lv_increment ? (I) \
3871 : (use == lv_decrement ? (D) : (AS))))
3872 if (TREE_CODE (arg
) == COMPONENT_REF
)
3874 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
3875 readonly_error (TREE_OPERAND (arg
, 0), use
);
3877 error (READONLY_MSG (G_("assignment of read-only member %qD"),
3878 G_("increment of read-only member %qD"),
3879 G_("decrement of read-only member %qD"),
3880 G_("read-only member %qD used as %<asm%> output")),
3881 TREE_OPERAND (arg
, 1));
3883 else if (TREE_CODE (arg
) == VAR_DECL
)
3884 error (READONLY_MSG (G_("assignment of read-only variable %qD"),
3885 G_("increment of read-only variable %qD"),
3886 G_("decrement of read-only variable %qD"),
3887 G_("read-only variable %qD used as %<asm%> output")),
3890 error (READONLY_MSG (G_("assignment of read-only location %qE"),
3891 G_("increment of read-only location %qE"),
3892 G_("decrement of read-only location %qE"),
3893 G_("read-only location %qE used as %<asm%> output")),
3897 /* Give a warning for storing in something that is read-only in GCC
3898 terms but not const in ISO C terms. */
3901 readonly_warning (tree arg
, enum lvalue_use use
)
3906 warning (0, "assignment of read-only location %qE", arg
);
3909 warning (0, "increment of read-only location %qE", arg
);
3912 warning (0, "decrement of read-only location %qE", arg
);
3921 /* Return nonzero if REF is an lvalue valid for this language;
3922 otherwise, print an error message and return zero. USE says
3923 how the lvalue is being used and so selects the error message. */
3926 lvalue_or_else (const_tree ref
, enum lvalue_use use
)
3928 int win
= lvalue_p (ref
);
3936 /* Mark EXP saying that we need to be able to take the
3937 address of it; it should not be allocated in a register.
3938 Returns true if successful. */
3941 c_mark_addressable (tree exp
)
3946 switch (TREE_CODE (x
))
3949 if (DECL_C_BIT_FIELD (TREE_OPERAND (x
, 1)))
3952 ("cannot take address of bit-field %qD", TREE_OPERAND (x
, 1));
3956 /* ... fall through ... */
3962 x
= TREE_OPERAND (x
, 0);
3965 case COMPOUND_LITERAL_EXPR
:
3967 TREE_ADDRESSABLE (x
) = 1;
3974 if (C_DECL_REGISTER (x
)
3975 && DECL_NONLOCAL (x
))
3977 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
3980 ("global register variable %qD used in nested function", x
);
3983 pedwarn (input_location
, 0, "register variable %qD used in nested function", x
);
3985 else if (C_DECL_REGISTER (x
))
3987 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
3988 error ("address of global register variable %qD requested", x
);
3990 error ("address of register variable %qD requested", x
);
3996 TREE_ADDRESSABLE (x
) = 1;
4003 /* Convert EXPR to TYPE, warning about conversion problems with
4004 constants. SEMANTIC_TYPE is the type this conversion would use
4005 without excess precision. If SEMANTIC_TYPE is NULL, this function
4006 is equivalent to convert_and_check. This function is a wrapper that
4007 handles conversions that may be different than
4008 the usual ones because of excess precision. */
4011 ep_convert_and_check (tree type
, tree expr
, tree semantic_type
)
4013 if (TREE_TYPE (expr
) == type
)
4017 return convert_and_check (type
, expr
);
4019 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
4020 && TREE_TYPE (expr
) != semantic_type
)
4022 /* For integers, we need to check the real conversion, not
4023 the conversion to the excess precision type. */
4024 expr
= convert_and_check (semantic_type
, expr
);
4026 /* Result type is the excess precision type, which should be
4027 large enough, so do not check. */
4028 return convert (type
, expr
);
4031 /* Build and return a conditional expression IFEXP ? OP1 : OP2. If
4032 IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4033 if folded to an integer constant then the unselected half may
4034 contain arbitrary operations not normally permitted in constant
4035 expressions. Set the location of the expression to LOC. */
4038 build_conditional_expr (location_t colon_loc
, tree ifexp
, bool ifexp_bcp
,
4039 tree op1
, tree op1_original_type
, tree op2
,
4040 tree op2_original_type
)
4044 enum tree_code code1
;
4045 enum tree_code code2
;
4046 tree result_type
= NULL
;
4047 tree semantic_result_type
= NULL
;
4048 tree orig_op1
= op1
, orig_op2
= op2
;
4049 bool int_const
, op1_int_operands
, op2_int_operands
, int_operands
;
4050 bool ifexp_int_operands
;
4054 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
4055 if (op1_int_operands
)
4056 op1
= remove_c_maybe_const_expr (op1
);
4057 op2_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op2
);
4058 if (op2_int_operands
)
4059 op2
= remove_c_maybe_const_expr (op2
);
4060 ifexp_int_operands
= EXPR_INT_CONST_OPERANDS (ifexp
);
4061 if (ifexp_int_operands
)
4062 ifexp
= remove_c_maybe_const_expr (ifexp
);
4064 /* Promote both alternatives. */
4066 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
4067 op1
= default_conversion (op1
);
4068 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
4069 op2
= default_conversion (op2
);
4071 if (TREE_CODE (ifexp
) == ERROR_MARK
4072 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
4073 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
4074 return error_mark_node
;
4076 type1
= TREE_TYPE (op1
);
4077 code1
= TREE_CODE (type1
);
4078 type2
= TREE_TYPE (op2
);
4079 code2
= TREE_CODE (type2
);
4081 /* C90 does not permit non-lvalue arrays in conditional expressions.
4082 In C99 they will be pointers by now. */
4083 if (code1
== ARRAY_TYPE
|| code2
== ARRAY_TYPE
)
4085 error_at (colon_loc
, "non-lvalue array in conditional expression");
4086 return error_mark_node
;
4089 objc_ok
= objc_compare_types (type1
, type2
, -3, NULL_TREE
);
4091 if ((TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
4092 || TREE_CODE (op2
) == EXCESS_PRECISION_EXPR
)
4093 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4094 || code1
== COMPLEX_TYPE
)
4095 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
4096 || code2
== COMPLEX_TYPE
))
4098 semantic_result_type
= c_common_type (type1
, type2
);
4099 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
4101 op1
= TREE_OPERAND (op1
, 0);
4102 type1
= TREE_TYPE (op1
);
4103 gcc_assert (TREE_CODE (type1
) == code1
);
4105 if (TREE_CODE (op2
) == EXCESS_PRECISION_EXPR
)
4107 op2
= TREE_OPERAND (op2
, 0);
4108 type2
= TREE_TYPE (op2
);
4109 gcc_assert (TREE_CODE (type2
) == code2
);
4113 if (warn_cxx_compat
)
4115 tree t1
= op1_original_type
? op1_original_type
: TREE_TYPE (orig_op1
);
4116 tree t2
= op2_original_type
? op2_original_type
: TREE_TYPE (orig_op2
);
4118 if (TREE_CODE (t1
) == ENUMERAL_TYPE
4119 && TREE_CODE (t2
) == ENUMERAL_TYPE
4120 && TYPE_MAIN_VARIANT (t1
) != TYPE_MAIN_VARIANT (t2
))
4121 warning_at (colon_loc
, OPT_Wc___compat
,
4122 ("different enum types in conditional is "
4123 "invalid in C++: %qT vs %qT"),
4127 /* Quickly detect the usual case where op1 and op2 have the same type
4129 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
4132 result_type
= type1
;
4134 result_type
= TYPE_MAIN_VARIANT (type1
);
4136 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4137 || code1
== COMPLEX_TYPE
)
4138 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
4139 || code2
== COMPLEX_TYPE
))
4141 result_type
= c_common_type (type1
, type2
);
4143 /* If -Wsign-compare, warn here if type1 and type2 have
4144 different signedness. We'll promote the signed to unsigned
4145 and later code won't know it used to be different.
4146 Do this check on the original types, so that explicit casts
4147 will be considered, but default promotions won't. */
4148 if (c_inhibit_evaluation_warnings
== 0)
4150 int unsigned_op1
= TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
4151 int unsigned_op2
= TYPE_UNSIGNED (TREE_TYPE (orig_op2
));
4153 if (unsigned_op1
^ unsigned_op2
)
4157 /* Do not warn if the result type is signed, since the
4158 signed type will only be chosen if it can represent
4159 all the values of the unsigned type. */
4160 if (!TYPE_UNSIGNED (result_type
))
4164 bool op1_maybe_const
= true;
4165 bool op2_maybe_const
= true;
4167 /* Do not warn if the signed quantity is an
4168 unsuffixed integer literal (or some static
4169 constant expression involving such literals) and
4170 it is non-negative. This warning requires the
4171 operands to be folded for best results, so do
4172 that folding in this case even without
4173 warn_sign_compare to avoid warning options
4174 possibly affecting code generation. */
4175 c_inhibit_evaluation_warnings
4176 += (ifexp
== truthvalue_false_node
);
4177 op1
= c_fully_fold (op1
, require_constant_value
,
4179 c_inhibit_evaluation_warnings
4180 -= (ifexp
== truthvalue_false_node
);
4182 c_inhibit_evaluation_warnings
4183 += (ifexp
== truthvalue_true_node
);
4184 op2
= c_fully_fold (op2
, require_constant_value
,
4186 c_inhibit_evaluation_warnings
4187 -= (ifexp
== truthvalue_true_node
);
4189 if (warn_sign_compare
)
4192 && tree_expr_nonnegative_warnv_p (op1
, &ovf
))
4194 && tree_expr_nonnegative_warnv_p (op2
, &ovf
)))
4197 warning_at (colon_loc
, OPT_Wsign_compare
,
4198 ("signed and unsigned type in "
4199 "conditional expression"));
4201 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
4202 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
4203 if (!op2_maybe_const
|| TREE_CODE (op2
) != INTEGER_CST
)
4204 op2
= c_wrap_maybe_const (op2
, !op2_maybe_const
);
4209 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
4211 if (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
)
4212 pedwarn (colon_loc
, OPT_pedantic
,
4213 "ISO C forbids conditional expr with only one void side");
4214 result_type
= void_type_node
;
4216 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
4218 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
4219 addr_space_t as2
= TYPE_ADDR_SPACE (TREE_TYPE (type2
));
4220 addr_space_t as_common
;
4222 if (comp_target_types (colon_loc
, type1
, type2
))
4223 result_type
= common_pointer_type (type1
, type2
);
4224 else if (null_pointer_constant_p (orig_op1
))
4225 result_type
= type2
;
4226 else if (null_pointer_constant_p (orig_op2
))
4227 result_type
= type1
;
4228 else if (!addr_space_superset (as1
, as2
, &as_common
))
4230 error_at (colon_loc
, "pointers to disjoint address spaces "
4231 "used in conditional expression");
4232 return error_mark_node
;
4234 else if (VOID_TYPE_P (TREE_TYPE (type1
)))
4236 if (TREE_CODE (TREE_TYPE (type2
)) == FUNCTION_TYPE
)
4237 pedwarn (colon_loc
, OPT_pedantic
,
4238 "ISO C forbids conditional expr between "
4239 "%<void *%> and function pointer");
4240 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type1
),
4241 TREE_TYPE (type2
)));
4243 else if (VOID_TYPE_P (TREE_TYPE (type2
)))
4245 if (TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
4246 pedwarn (colon_loc
, OPT_pedantic
,
4247 "ISO C forbids conditional expr between "
4248 "%<void *%> and function pointer");
4249 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
4250 TREE_TYPE (type1
)));
4254 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
4257 pedwarn (colon_loc
, 0,
4258 "pointer type mismatch in conditional expression");
4259 result_type
= build_pointer_type
4260 (build_qualified_type (void_type_node
, qual
));
4263 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
4265 if (!null_pointer_constant_p (orig_op2
))
4266 pedwarn (colon_loc
, 0,
4267 "pointer/integer type mismatch in conditional expression");
4270 op2
= null_pointer_node
;
4272 result_type
= type1
;
4274 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4276 if (!null_pointer_constant_p (orig_op1
))
4277 pedwarn (colon_loc
, 0,
4278 "pointer/integer type mismatch in conditional expression");
4281 op1
= null_pointer_node
;
4283 result_type
= type2
;
4288 if (flag_cond_mismatch
)
4289 result_type
= void_type_node
;
4292 error_at (colon_loc
, "type mismatch in conditional expression");
4293 return error_mark_node
;
4297 /* Merge const and volatile flags of the incoming types. */
4299 = build_type_variant (result_type
,
4300 TYPE_READONLY (type1
) || TYPE_READONLY (type2
),
4301 TYPE_VOLATILE (type1
) || TYPE_VOLATILE (type2
));
4303 op1
= ep_convert_and_check (result_type
, op1
, semantic_result_type
);
4304 op2
= ep_convert_and_check (result_type
, op2
, semantic_result_type
);
4306 if (ifexp_bcp
&& ifexp
== truthvalue_true_node
)
4308 op2_int_operands
= true;
4309 op1
= c_fully_fold (op1
, require_constant_value
, NULL
);
4311 if (ifexp_bcp
&& ifexp
== truthvalue_false_node
)
4313 op1_int_operands
= true;
4314 op2
= c_fully_fold (op2
, require_constant_value
, NULL
);
4316 int_const
= int_operands
= (ifexp_int_operands
4318 && op2_int_operands
);
4321 int_const
= ((ifexp
== truthvalue_true_node
4322 && TREE_CODE (orig_op1
) == INTEGER_CST
4323 && !TREE_OVERFLOW (orig_op1
))
4324 || (ifexp
== truthvalue_false_node
4325 && TREE_CODE (orig_op2
) == INTEGER_CST
4326 && !TREE_OVERFLOW (orig_op2
)));
4328 if (int_const
|| (ifexp_bcp
&& TREE_CODE (ifexp
) == INTEGER_CST
))
4329 ret
= fold_build3_loc (colon_loc
, COND_EXPR
, result_type
, ifexp
, op1
, op2
);
4332 ret
= build3 (COND_EXPR
, result_type
, ifexp
, op1
, op2
);
4334 ret
= note_integer_operands (ret
);
4336 if (semantic_result_type
)
4337 ret
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, ret
);
4339 protected_set_expr_location (ret
, colon_loc
);
4343 /* Return a compound expression that performs two expressions and
4344 returns the value of the second of them.
4346 LOC is the location of the COMPOUND_EXPR. */
4349 build_compound_expr (location_t loc
, tree expr1
, tree expr2
)
4351 bool expr1_int_operands
, expr2_int_operands
;
4352 tree eptype
= NULL_TREE
;
4355 expr1_int_operands
= EXPR_INT_CONST_OPERANDS (expr1
);
4356 if (expr1_int_operands
)
4357 expr1
= remove_c_maybe_const_expr (expr1
);
4358 expr2_int_operands
= EXPR_INT_CONST_OPERANDS (expr2
);
4359 if (expr2_int_operands
)
4360 expr2
= remove_c_maybe_const_expr (expr2
);
4362 if (TREE_CODE (expr1
) == EXCESS_PRECISION_EXPR
)
4363 expr1
= TREE_OPERAND (expr1
, 0);
4364 if (TREE_CODE (expr2
) == EXCESS_PRECISION_EXPR
)
4366 eptype
= TREE_TYPE (expr2
);
4367 expr2
= TREE_OPERAND (expr2
, 0);
4370 if (!TREE_SIDE_EFFECTS (expr1
))
4372 /* The left-hand operand of a comma expression is like an expression
4373 statement: with -Wunused, we should warn if it doesn't have
4374 any side-effects, unless it was explicitly cast to (void). */
4375 if (warn_unused_value
)
4377 if (VOID_TYPE_P (TREE_TYPE (expr1
))
4378 && CONVERT_EXPR_P (expr1
))
4380 else if (VOID_TYPE_P (TREE_TYPE (expr1
))
4381 && TREE_CODE (expr1
) == COMPOUND_EXPR
4382 && CONVERT_EXPR_P (TREE_OPERAND (expr1
, 1)))
4383 ; /* (void) a, (void) b, c */
4385 warning_at (loc
, OPT_Wunused_value
,
4386 "left-hand operand of comma expression has no effect");
4390 /* With -Wunused, we should also warn if the left-hand operand does have
4391 side-effects, but computes a value which is not used. For example, in
4392 `foo() + bar(), baz()' the result of the `+' operator is not used,
4393 so we should issue a warning. */
4394 else if (warn_unused_value
)
4395 warn_if_unused_value (expr1
, loc
);
4397 if (expr2
== error_mark_node
)
4398 return error_mark_node
;
4400 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr2
), expr1
, expr2
);
4403 && expr1_int_operands
4404 && expr2_int_operands
)
4405 ret
= note_integer_operands (ret
);
4408 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
4410 protected_set_expr_location (ret
, loc
);
4414 /* Issue -Wcast-qual warnings when appropriate. TYPE is the type to
4415 which we are casting. OTYPE is the type of the expression being
4416 cast. Both TYPE and OTYPE are pointer types. LOC is the location
4417 of the cast. -Wcast-qual appeared on the command line. Named
4418 address space qualifiers are not handled here, because they result
4419 in different warnings. */
4422 handle_warn_cast_qual (location_t loc
, tree type
, tree otype
)
4424 tree in_type
= type
;
4425 tree in_otype
= otype
;
4430 /* Check that the qualifiers on IN_TYPE are a superset of the
4431 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
4432 nodes is uninteresting and we stop as soon as we hit a
4433 non-POINTER_TYPE node on either type. */
4436 in_otype
= TREE_TYPE (in_otype
);
4437 in_type
= TREE_TYPE (in_type
);
4439 /* GNU C allows cv-qualified function types. 'const' means the
4440 function is very pure, 'volatile' means it can't return. We
4441 need to warn when such qualifiers are added, not when they're
4443 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
4444 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
4445 added
|= (TYPE_QUALS_NO_ADDR_SPACE (in_type
)
4446 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype
));
4448 discarded
|= (TYPE_QUALS_NO_ADDR_SPACE (in_otype
)
4449 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type
));
4451 while (TREE_CODE (in_type
) == POINTER_TYPE
4452 && TREE_CODE (in_otype
) == POINTER_TYPE
);
4455 warning_at (loc
, OPT_Wcast_qual
,
4456 "cast adds %q#v qualifier to function type", added
);
4459 /* There are qualifiers present in IN_OTYPE that are not present
4461 warning_at (loc
, OPT_Wcast_qual
,
4462 "cast discards %q#v qualifier from pointer target type",
4465 if (added
|| discarded
)
4468 /* A cast from **T to const **T is unsafe, because it can cause a
4469 const value to be changed with no additional warning. We only
4470 issue this warning if T is the same on both sides, and we only
4471 issue the warning if there are the same number of pointers on
4472 both sides, as otherwise the cast is clearly unsafe anyhow. A
4473 cast is unsafe when a qualifier is added at one level and const
4474 is not present at all outer levels.
4476 To issue this warning, we check at each level whether the cast
4477 adds new qualifiers not already seen. We don't need to special
4478 case function types, as they won't have the same
4479 TYPE_MAIN_VARIANT. */
4481 if (TYPE_MAIN_VARIANT (in_type
) != TYPE_MAIN_VARIANT (in_otype
))
4483 if (TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
)
4488 is_const
= TYPE_READONLY (TREE_TYPE (in_type
));
4491 in_type
= TREE_TYPE (in_type
);
4492 in_otype
= TREE_TYPE (in_otype
);
4493 if ((TYPE_QUALS (in_type
) &~ TYPE_QUALS (in_otype
)) != 0
4496 warning_at (loc
, OPT_Wcast_qual
,
4497 "to be safe all intermediate pointers in cast from "
4498 "%qT to %qT must be %<const%> qualified",
4503 is_const
= TYPE_READONLY (in_type
);
4505 while (TREE_CODE (in_type
) == POINTER_TYPE
);
4508 /* Build an expression representing a cast to type TYPE of expression EXPR.
4509 LOC is the location of the cast-- typically the open paren of the cast. */
4512 build_c_cast (location_t loc
, tree type
, tree expr
)
4516 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
4517 expr
= TREE_OPERAND (expr
, 0);
4521 if (type
== error_mark_node
|| expr
== error_mark_node
)
4522 return error_mark_node
;
4524 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
4525 only in <protocol> qualifications. But when constructing cast expressions,
4526 the protocols do matter and must be kept around. */
4527 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
4528 return build1 (NOP_EXPR
, type
, expr
);
4530 type
= TYPE_MAIN_VARIANT (type
);
4532 if (TREE_CODE (type
) == ARRAY_TYPE
)
4534 error_at (loc
, "cast specifies array type");
4535 return error_mark_node
;
4538 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4540 error_at (loc
, "cast specifies function type");
4541 return error_mark_node
;
4544 if (!VOID_TYPE_P (type
))
4546 value
= require_complete_type (value
);
4547 if (value
== error_mark_node
)
4548 return error_mark_node
;
4551 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
4553 if (TREE_CODE (type
) == RECORD_TYPE
4554 || TREE_CODE (type
) == UNION_TYPE
)
4555 pedwarn (loc
, OPT_pedantic
,
4556 "ISO C forbids casting nonscalar to the same type");
4558 else if (TREE_CODE (type
) == UNION_TYPE
)
4562 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4563 if (TREE_TYPE (field
) != error_mark_node
4564 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
4565 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
4571 bool maybe_const
= true;
4573 pedwarn (loc
, OPT_pedantic
, "ISO C forbids casts to union type");
4574 t
= c_fully_fold (value
, false, &maybe_const
);
4575 t
= build_constructor_single (type
, field
, t
);
4577 t
= c_wrap_maybe_const (t
, true);
4578 t
= digest_init (loc
, type
, t
,
4579 NULL_TREE
, false, true, 0);
4580 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
4583 error_at (loc
, "cast to union type from type not present in union");
4584 return error_mark_node
;
4590 if (type
== void_type_node
)
4592 tree t
= build1 (CONVERT_EXPR
, type
, value
);
4593 SET_EXPR_LOCATION (t
, loc
);
4597 otype
= TREE_TYPE (value
);
4599 /* Optionally warn about potentially worrisome casts. */
4601 && TREE_CODE (type
) == POINTER_TYPE
4602 && TREE_CODE (otype
) == POINTER_TYPE
)
4603 handle_warn_cast_qual (loc
, type
, otype
);
4605 /* Warn about conversions between pointers to disjoint
4607 if (TREE_CODE (type
) == POINTER_TYPE
4608 && TREE_CODE (otype
) == POINTER_TYPE
4609 && !null_pointer_constant_p (value
))
4611 addr_space_t as_to
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
4612 addr_space_t as_from
= TYPE_ADDR_SPACE (TREE_TYPE (otype
));
4613 addr_space_t as_common
;
4615 if (!addr_space_superset (as_to
, as_from
, &as_common
))
4617 if (ADDR_SPACE_GENERIC_P (as_from
))
4618 warning_at (loc
, 0, "cast to %s address space pointer "
4619 "from disjoint generic address space pointer",
4620 c_addr_space_name (as_to
));
4622 else if (ADDR_SPACE_GENERIC_P (as_to
))
4623 warning_at (loc
, 0, "cast to generic address space pointer "
4624 "from disjoint %s address space pointer",
4625 c_addr_space_name (as_from
));
4628 warning_at (loc
, 0, "cast to %s address space pointer "
4629 "from disjoint %s address space pointer",
4630 c_addr_space_name (as_to
),
4631 c_addr_space_name (as_from
));
4635 /* Warn about possible alignment problems. */
4636 if (STRICT_ALIGNMENT
4637 && TREE_CODE (type
) == POINTER_TYPE
4638 && TREE_CODE (otype
) == POINTER_TYPE
4639 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
4640 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
4641 /* Don't warn about opaque types, where the actual alignment
4642 restriction is unknown. */
4643 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
4644 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
4645 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
4646 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
4647 warning_at (loc
, OPT_Wcast_align
,
4648 "cast increases required alignment of target type");
4650 if (TREE_CODE (type
) == INTEGER_TYPE
4651 && TREE_CODE (otype
) == POINTER_TYPE
4652 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
4653 /* Unlike conversion of integers to pointers, where the
4654 warning is disabled for converting constants because
4655 of cases such as SIG_*, warn about converting constant
4656 pointers to integers. In some cases it may cause unwanted
4657 sign extension, and a warning is appropriate. */
4658 warning_at (loc
, OPT_Wpointer_to_int_cast
,
4659 "cast from pointer to integer of different size");
4661 if (TREE_CODE (value
) == CALL_EXPR
4662 && TREE_CODE (type
) != TREE_CODE (otype
))
4663 warning_at (loc
, OPT_Wbad_function_cast
,
4664 "cast from function call of type %qT "
4665 "to non-matching type %qT", otype
, type
);
4667 if (TREE_CODE (type
) == POINTER_TYPE
4668 && TREE_CODE (otype
) == INTEGER_TYPE
4669 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
4670 /* Don't warn about converting any constant. */
4671 && !TREE_CONSTANT (value
))
4673 OPT_Wint_to_pointer_cast
, "cast to pointer from integer "
4674 "of different size");
4676 if (warn_strict_aliasing
<= 2)
4677 strict_aliasing_warning (otype
, type
, expr
);
4679 /* If pedantic, warn for conversions between function and object
4680 pointer types, except for converting a null pointer constant
4681 to function pointer type. */
4683 && TREE_CODE (type
) == POINTER_TYPE
4684 && TREE_CODE (otype
) == POINTER_TYPE
4685 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
4686 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
4687 pedwarn (loc
, OPT_pedantic
, "ISO C forbids "
4688 "conversion of function pointer to object pointer type");
4691 && TREE_CODE (type
) == POINTER_TYPE
4692 && TREE_CODE (otype
) == POINTER_TYPE
4693 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
4694 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
4695 && !null_pointer_constant_p (value
))
4696 pedwarn (loc
, OPT_pedantic
, "ISO C forbids "
4697 "conversion of object pointer to function pointer type");
4700 value
= convert (type
, value
);
4702 /* Ignore any integer overflow caused by the cast. */
4703 if (TREE_CODE (value
) == INTEGER_CST
&& !FLOAT_TYPE_P (otype
))
4705 if (CONSTANT_CLASS_P (ovalue
) && TREE_OVERFLOW (ovalue
))
4707 if (!TREE_OVERFLOW (value
))
4709 /* Avoid clobbering a shared constant. */
4710 value
= copy_node (value
);
4711 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
4714 else if (TREE_OVERFLOW (value
))
4715 /* Reset VALUE's overflow flags, ensuring constant sharing. */
4716 value
= build_int_cst_wide (TREE_TYPE (value
),
4717 TREE_INT_CST_LOW (value
),
4718 TREE_INT_CST_HIGH (value
));
4722 /* Don't let a cast be an lvalue. */
4724 value
= non_lvalue_loc (loc
, value
);
4726 /* Don't allow the results of casting to floating-point or complex
4727 types be confused with actual constants, or casts involving
4728 integer and pointer types other than direct integer-to-integer
4729 and integer-to-pointer be confused with integer constant
4730 expressions and null pointer constants. */
4731 if (TREE_CODE (value
) == REAL_CST
4732 || TREE_CODE (value
) == COMPLEX_CST
4733 || (TREE_CODE (value
) == INTEGER_CST
4734 && !((TREE_CODE (expr
) == INTEGER_CST
4735 && INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
4736 || TREE_CODE (expr
) == REAL_CST
4737 || TREE_CODE (expr
) == COMPLEX_CST
)))
4738 value
= build1 (NOP_EXPR
, type
, value
);
4740 if (CAN_HAVE_LOCATION_P (value
))
4741 SET_EXPR_LOCATION (value
, loc
);
4745 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
4746 location of the open paren of the cast, or the position of the cast
4749 c_cast_expr (location_t loc
, struct c_type_name
*type_name
, tree expr
)
4752 tree type_expr
= NULL_TREE
;
4753 bool type_expr_const
= true;
4755 int saved_wsp
= warn_strict_prototypes
;
4757 /* This avoids warnings about unprototyped casts on
4758 integers. E.g. "#define SIG_DFL (void(*)())0". */
4759 if (TREE_CODE (expr
) == INTEGER_CST
)
4760 warn_strict_prototypes
= 0;
4761 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
4762 warn_strict_prototypes
= saved_wsp
;
4764 ret
= build_c_cast (loc
, type
, expr
);
4767 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
), type_expr
, ret
);
4768 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = !type_expr_const
;
4769 SET_EXPR_LOCATION (ret
, loc
);
4772 if (CAN_HAVE_LOCATION_P (ret
) && !EXPR_HAS_LOCATION (ret
))
4773 SET_EXPR_LOCATION (ret
, loc
);
4775 /* C++ does not permits types to be defined in a cast. */
4776 if (warn_cxx_compat
&& type_name
->specs
->tag_defined_p
)
4777 warning_at (loc
, OPT_Wc___compat
,
4778 "defining a type in a cast is invalid in C++");
4783 /* Build an assignment expression of lvalue LHS from value RHS.
4784 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
4785 may differ from TREE_TYPE (LHS) for an enum bitfield.
4786 MODIFYCODE is the code for a binary operator that we use
4787 to combine the old value of LHS with RHS to get the new value.
4788 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4789 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
4790 which may differ from TREE_TYPE (RHS) for an enum value.
4792 LOCATION is the location of the MODIFYCODE operator.
4793 RHS_LOC is the location of the RHS. */
4796 build_modify_expr (location_t location
, tree lhs
, tree lhs_origtype
,
4797 enum tree_code modifycode
,
4798 location_t rhs_loc
, tree rhs
, tree rhs_origtype
)
4802 tree rhs_semantic_type
= NULL_TREE
;
4803 tree lhstype
= TREE_TYPE (lhs
);
4804 tree olhstype
= lhstype
;
4807 /* Types that aren't fully specified cannot be used in assignments. */
4808 lhs
= require_complete_type (lhs
);
4810 /* Avoid duplicate error messages from operands that had errors. */
4811 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
4812 return error_mark_node
;
4814 if (!lvalue_or_else (lhs
, lv_assign
))
4815 return error_mark_node
;
4817 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
4819 rhs_semantic_type
= TREE_TYPE (rhs
);
4820 rhs
= TREE_OPERAND (rhs
, 0);
4825 if (TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
4827 tree inner
= build_modify_expr (location
, C_MAYBE_CONST_EXPR_EXPR (lhs
),
4828 lhs_origtype
, modifycode
, rhs_loc
, rhs
,
4830 if (inner
== error_mark_node
)
4831 return error_mark_node
;
4832 result
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
4833 C_MAYBE_CONST_EXPR_PRE (lhs
), inner
);
4834 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs
));
4835 C_MAYBE_CONST_EXPR_NON_CONST (result
) = 1;
4836 protected_set_expr_location (result
, location
);
4840 /* If a binary op has been requested, combine the old LHS value with the RHS
4841 producing the value we should actually store into the LHS. */
4843 if (modifycode
!= NOP_EXPR
)
4845 lhs
= c_fully_fold (lhs
, false, NULL
);
4846 lhs
= stabilize_reference (lhs
);
4847 newrhs
= build_binary_op (location
,
4848 modifycode
, lhs
, rhs
, 1);
4850 /* The original type of the right hand side is no longer
4852 rhs_origtype
= NULL_TREE
;
4855 /* Give an error for storing in something that is 'const'. */
4857 if (TYPE_READONLY (lhstype
)
4858 || ((TREE_CODE (lhstype
) == RECORD_TYPE
4859 || TREE_CODE (lhstype
) == UNION_TYPE
)
4860 && C_TYPE_FIELDS_READONLY (lhstype
)))
4862 readonly_error (lhs
, lv_assign
);
4863 return error_mark_node
;
4865 else if (TREE_READONLY (lhs
))
4866 readonly_warning (lhs
, lv_assign
);
4868 /* If storing into a structure or union member,
4869 it has probably been given type `int'.
4870 Compute the type that would go with
4871 the actual amount of storage the member occupies. */
4873 if (TREE_CODE (lhs
) == COMPONENT_REF
4874 && (TREE_CODE (lhstype
) == INTEGER_TYPE
4875 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
4876 || TREE_CODE (lhstype
) == REAL_TYPE
4877 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
4878 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
4880 /* If storing in a field that is in actuality a short or narrower than one,
4881 we must store in the field in its actual type. */
4883 if (lhstype
!= TREE_TYPE (lhs
))
4885 lhs
= copy_node (lhs
);
4886 TREE_TYPE (lhs
) = lhstype
;
4889 /* Issue -Wc++-compat warnings about an assignment to an enum type
4890 when LHS does not have its original type. This happens for,
4891 e.g., an enum bitfield in a struct. */
4893 && lhs_origtype
!= NULL_TREE
4894 && lhs_origtype
!= lhstype
4895 && TREE_CODE (lhs_origtype
) == ENUMERAL_TYPE
)
4897 tree checktype
= (rhs_origtype
!= NULL_TREE
4900 if (checktype
!= error_mark_node
4901 && TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (lhs_origtype
))
4902 warning_at (location
, OPT_Wc___compat
,
4903 "enum conversion in assignment is invalid in C++");
4906 /* Convert new value to destination type. Fold it first, then
4907 restore any excess precision information, for the sake of
4908 conversion warnings. */
4910 npc
= null_pointer_constant_p (newrhs
);
4911 newrhs
= c_fully_fold (newrhs
, false, NULL
);
4912 if (rhs_semantic_type
)
4913 newrhs
= build1 (EXCESS_PRECISION_EXPR
, rhs_semantic_type
, newrhs
);
4914 newrhs
= convert_for_assignment (location
, lhstype
, newrhs
, rhs_origtype
,
4915 ic_assign
, npc
, NULL_TREE
, NULL_TREE
, 0);
4916 if (TREE_CODE (newrhs
) == ERROR_MARK
)
4917 return error_mark_node
;
4919 /* Emit ObjC write barrier, if necessary. */
4920 if (c_dialect_objc () && flag_objc_gc
)
4922 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
4925 protected_set_expr_location (result
, location
);
4930 /* Scan operands. */
4932 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
4933 TREE_SIDE_EFFECTS (result
) = 1;
4934 protected_set_expr_location (result
, location
);
4936 /* If we got the LHS in a different type for storing in,
4937 convert the result back to the nominal type of LHS
4938 so that the value we return always has the same type
4939 as the LHS argument. */
4941 if (olhstype
== TREE_TYPE (result
))
4944 result
= convert_for_assignment (location
, olhstype
, result
, rhs_origtype
,
4945 ic_assign
, false, NULL_TREE
, NULL_TREE
, 0);
4946 protected_set_expr_location (result
, location
);
4950 /* Convert value RHS to type TYPE as preparation for an assignment to
4951 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
4952 original type of RHS; this differs from TREE_TYPE (RHS) for enum
4953 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
4954 constant before any folding.
4955 The real work of conversion is done by `convert'.
4956 The purpose of this function is to generate error messages
4957 for assignments that are not allowed in C.
4958 ERRTYPE says whether it is argument passing, assignment,
4959 initialization or return.
4961 LOCATION is the location of the RHS.
4962 FUNCTION is a tree for the function being called.
4963 PARMNUM is the number of the argument, for printing in error messages. */
4966 convert_for_assignment (location_t location
, tree type
, tree rhs
,
4967 tree origtype
, enum impl_conv errtype
,
4968 bool null_pointer_constant
, tree fundecl
,
4969 tree function
, int parmnum
)
4971 enum tree_code codel
= TREE_CODE (type
);
4972 tree orig_rhs
= rhs
;
4974 enum tree_code coder
;
4975 tree rname
= NULL_TREE
;
4976 bool objc_ok
= false;
4978 if (errtype
== ic_argpass
)
4981 /* Change pointer to function to the function itself for
4983 if (TREE_CODE (function
) == ADDR_EXPR
4984 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
4985 function
= TREE_OPERAND (function
, 0);
4987 /* Handle an ObjC selector specially for diagnostics. */
4988 selector
= objc_message_selector ();
4990 if (selector
&& parmnum
> 2)
4997 /* This macro is used to emit diagnostics to ensure that all format
4998 strings are complete sentences, visible to gettext and checked at
5000 #define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE) \
5005 if (pedwarn (LOCATION, OPT, AR, parmnum, rname)) \
5006 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5007 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5008 "expected %qT but argument is of type %qT", \
5012 pedwarn (LOCATION, OPT, AS); \
5015 pedwarn_init (LOCATION, OPT, IN); \
5018 pedwarn (LOCATION, OPT, RE); \
5021 gcc_unreachable (); \
5025 /* This macro is used to emit diagnostics to ensure that all format
5026 strings are complete sentences, visible to gettext and checked at
5027 compile time. It is the same as WARN_FOR_ASSIGNMENT but with an
5028 extra parameter to enumerate qualifiers. */
5030 #define WARN_FOR_QUALIFIERS(LOCATION, OPT, AR, AS, IN, RE, QUALS) \
5035 if (pedwarn (LOCATION, OPT, AR, parmnum, rname, QUALS)) \
5036 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5037 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5038 "expected %qT but argument is of type %qT", \
5042 pedwarn (LOCATION, OPT, AS, QUALS); \
5045 pedwarn (LOCATION, OPT, IN, QUALS); \
5048 pedwarn (LOCATION, OPT, RE, QUALS); \
5051 gcc_unreachable (); \
5055 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
5056 rhs
= TREE_OPERAND (rhs
, 0);
5058 rhstype
= TREE_TYPE (rhs
);
5059 coder
= TREE_CODE (rhstype
);
5061 if (coder
== ERROR_MARK
)
5062 return error_mark_node
;
5064 if (c_dialect_objc ())
5087 objc_ok
= objc_compare_types (type
, rhstype
, parmno
, rname
);
5090 if (warn_cxx_compat
)
5092 tree checktype
= origtype
!= NULL_TREE
? origtype
: rhstype
;
5093 if (checktype
!= error_mark_node
5094 && TREE_CODE (type
) == ENUMERAL_TYPE
5095 && TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (type
))
5097 WARN_FOR_ASSIGNMENT (input_location
, OPT_Wc___compat
,
5098 G_("enum conversion when passing argument "
5099 "%d of %qE is invalid in C++"),
5100 G_("enum conversion in assignment is "
5102 G_("enum conversion in initialization is "
5104 G_("enum conversion in return is "
5109 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
5112 if (coder
== VOID_TYPE
)
5114 /* Except for passing an argument to an unprototyped function,
5115 this is a constraint violation. When passing an argument to
5116 an unprototyped function, it is compile-time undefined;
5117 making it a constraint in that case was rejected in
5119 error_at (location
, "void value not ignored as it ought to be");
5120 return error_mark_node
;
5122 rhs
= require_complete_type (rhs
);
5123 if (rhs
== error_mark_node
)
5124 return error_mark_node
;
5125 /* A type converts to a reference to it.
5126 This code doesn't fully support references, it's just for the
5127 special case of va_start and va_copy. */
5128 if (codel
== REFERENCE_TYPE
5129 && comptypes (TREE_TYPE (type
), TREE_TYPE (rhs
)) == 1)
5131 if (!lvalue_p (rhs
))
5133 error_at (location
, "cannot pass rvalue to reference parameter");
5134 return error_mark_node
;
5136 if (!c_mark_addressable (rhs
))
5137 return error_mark_node
;
5138 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
5139 SET_EXPR_LOCATION (rhs
, location
);
5141 /* We already know that these two types are compatible, but they
5142 may not be exactly identical. In fact, `TREE_TYPE (type)' is
5143 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
5144 likely to be va_list, a typedef to __builtin_va_list, which
5145 is different enough that it will cause problems later. */
5146 if (TREE_TYPE (TREE_TYPE (rhs
)) != TREE_TYPE (type
))
5148 rhs
= build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), rhs
);
5149 SET_EXPR_LOCATION (rhs
, location
);
5152 rhs
= build1 (NOP_EXPR
, type
, rhs
);
5153 SET_EXPR_LOCATION (rhs
, location
);
5156 /* Some types can interconvert without explicit casts. */
5157 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
5158 && vector_types_convertible_p (type
, TREE_TYPE (rhs
), true))
5159 return convert (type
, rhs
);
5160 /* Arithmetic types all interconvert, and enum is treated like int. */
5161 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
5162 || codel
== FIXED_POINT_TYPE
5163 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
5164 || codel
== BOOLEAN_TYPE
)
5165 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
5166 || coder
== FIXED_POINT_TYPE
5167 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
5168 || coder
== BOOLEAN_TYPE
))
5171 bool save
= in_late_binary_op
;
5172 if (codel
== BOOLEAN_TYPE
)
5173 in_late_binary_op
= true;
5174 ret
= convert_and_check (type
, orig_rhs
);
5175 if (codel
== BOOLEAN_TYPE
)
5176 in_late_binary_op
= save
;
5180 /* Aggregates in different TUs might need conversion. */
5181 if ((codel
== RECORD_TYPE
|| codel
== UNION_TYPE
)
5183 && comptypes (type
, rhstype
))
5184 return convert_and_check (type
, rhs
);
5186 /* Conversion to a transparent union or record from its member types.
5187 This applies only to function arguments. */
5188 if (((codel
== UNION_TYPE
|| codel
== RECORD_TYPE
)
5189 && TYPE_TRANSPARENT_AGGR (type
))
5190 && errtype
== ic_argpass
)
5192 tree memb
, marginal_memb
= NULL_TREE
;
5194 for (memb
= TYPE_FIELDS (type
); memb
; memb
= TREE_CHAIN (memb
))
5196 tree memb_type
= TREE_TYPE (memb
);
5198 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
5199 TYPE_MAIN_VARIANT (rhstype
)))
5202 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
5205 if (coder
== POINTER_TYPE
)
5207 tree ttl
= TREE_TYPE (memb_type
);
5208 tree ttr
= TREE_TYPE (rhstype
);
5210 /* Any non-function converts to a [const][volatile] void *
5211 and vice versa; otherwise, targets must be the same.
5212 Meanwhile, the lhs target must have all the qualifiers of
5214 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
5215 || comp_target_types (location
, memb_type
, rhstype
))
5217 /* If this type won't generate any warnings, use it. */
5218 if (TYPE_QUALS (ttl
) == TYPE_QUALS (ttr
)
5219 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
5220 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
5221 ? ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
5222 == TYPE_QUALS (ttr
))
5223 : ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
5224 == TYPE_QUALS (ttl
))))
5227 /* Keep looking for a better type, but remember this one. */
5229 marginal_memb
= memb
;
5233 /* Can convert integer zero to any pointer type. */
5234 if (null_pointer_constant
)
5236 rhs
= null_pointer_node
;
5241 if (memb
|| marginal_memb
)
5245 /* We have only a marginally acceptable member type;
5246 it needs a warning. */
5247 tree ttl
= TREE_TYPE (TREE_TYPE (marginal_memb
));
5248 tree ttr
= TREE_TYPE (rhstype
);
5250 /* Const and volatile mean something different for function
5251 types, so the usual warnings are not appropriate. */
5252 if (TREE_CODE (ttr
) == FUNCTION_TYPE
5253 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
5255 /* Because const and volatile on functions are
5256 restrictions that say the function will not do
5257 certain things, it is okay to use a const or volatile
5258 function where an ordinary one is wanted, but not
5260 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
5261 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
5262 WARN_FOR_QUALIFIERS (location
, 0,
5263 G_("passing argument %d of %qE "
5264 "makes %q#v qualified function "
5265 "pointer from unqualified"),
5266 G_("assignment makes %q#v qualified "
5267 "function pointer from "
5269 G_("initialization makes %q#v qualified "
5270 "function pointer from "
5272 G_("return makes %q#v qualified function "
5273 "pointer from unqualified"),
5274 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
5276 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr
)
5277 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl
))
5278 WARN_FOR_QUALIFIERS (location
, 0,
5279 G_("passing argument %d of %qE discards "
5280 "%qv qualifier from pointer target type"),
5281 G_("assignment discards %qv qualifier "
5282 "from pointer target type"),
5283 G_("initialization discards %qv qualifier "
5284 "from pointer target type"),
5285 G_("return discards %qv qualifier from "
5286 "pointer target type"),
5287 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
5289 memb
= marginal_memb
;
5292 if (!fundecl
|| !DECL_IN_SYSTEM_HEADER (fundecl
))
5293 pedwarn (location
, OPT_pedantic
,
5294 "ISO C prohibits argument conversion to union type");
5296 rhs
= fold_convert_loc (location
, TREE_TYPE (memb
), rhs
);
5297 return build_constructor_single (type
, memb
, rhs
);
5301 /* Conversions among pointers */
5302 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
5303 && (coder
== codel
))
5305 tree ttl
= TREE_TYPE (type
);
5306 tree ttr
= TREE_TYPE (rhstype
);
5309 bool is_opaque_pointer
;
5310 int target_cmp
= 0; /* Cache comp_target_types () result. */
5314 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
5315 mvl
= TYPE_MAIN_VARIANT (mvl
);
5316 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
5317 mvr
= TYPE_MAIN_VARIANT (mvr
);
5318 /* Opaque pointers are treated like void pointers. */
5319 is_opaque_pointer
= vector_targets_convertible_p (ttl
, ttr
);
5321 /* C++ does not allow the implicit conversion void* -> T*. However,
5322 for the purpose of reducing the number of false positives, we
5323 tolerate the special case of
5327 where NULL is typically defined in C to be '(void *) 0'. */
5328 if (VOID_TYPE_P (ttr
) && rhs
!= null_pointer_node
&& !VOID_TYPE_P (ttl
))
5329 warning_at (location
, OPT_Wc___compat
,
5330 "request for implicit conversion "
5331 "from %qT to %qT not permitted in C++", rhstype
, type
);
5333 /* See if the pointers point to incompatible address spaces. */
5334 asl
= TYPE_ADDR_SPACE (ttl
);
5335 asr
= TYPE_ADDR_SPACE (ttr
);
5336 if (!null_pointer_constant_p (rhs
)
5337 && asr
!= asl
&& !targetm
.addr_space
.subset_p (asr
, asl
))
5342 error_at (location
, "passing argument %d of %qE from pointer to "
5343 "non-enclosed address space", parmnum
, rname
);
5346 error_at (location
, "assignment from pointer to "
5347 "non-enclosed address space");
5350 error_at (location
, "initialization from pointer to "
5351 "non-enclosed address space");
5354 error_at (location
, "return from pointer to "
5355 "non-enclosed address space");
5360 return error_mark_node
;
5363 /* Check if the right-hand side has a format attribute but the
5364 left-hand side doesn't. */
5365 if (warn_missing_format_attribute
5366 && check_missing_format_attribute (type
, rhstype
))
5371 warning_at (location
, OPT_Wmissing_format_attribute
,
5372 "argument %d of %qE might be "
5373 "a candidate for a format attribute",
5377 warning_at (location
, OPT_Wmissing_format_attribute
,
5378 "assignment left-hand side might be "
5379 "a candidate for a format attribute");
5382 warning_at (location
, OPT_Wmissing_format_attribute
,
5383 "initialization left-hand side might be "
5384 "a candidate for a format attribute");
5387 warning_at (location
, OPT_Wmissing_format_attribute
,
5388 "return type might be "
5389 "a candidate for a format attribute");
5396 /* Any non-function converts to a [const][volatile] void *
5397 and vice versa; otherwise, targets must be the same.
5398 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
5399 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
5400 || (target_cmp
= comp_target_types (location
, type
, rhstype
))
5401 || is_opaque_pointer
5402 || (c_common_unsigned_type (mvl
)
5403 == c_common_unsigned_type (mvr
)))
5406 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
5409 && !null_pointer_constant
5410 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
5411 WARN_FOR_ASSIGNMENT (location
, OPT_pedantic
,
5412 G_("ISO C forbids passing argument %d of "
5413 "%qE between function pointer "
5415 G_("ISO C forbids assignment between "
5416 "function pointer and %<void *%>"),
5417 G_("ISO C forbids initialization between "
5418 "function pointer and %<void *%>"),
5419 G_("ISO C forbids return between function "
5420 "pointer and %<void *%>"));
5421 /* Const and volatile mean something different for function types,
5422 so the usual warnings are not appropriate. */
5423 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
5424 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
5426 if (TYPE_QUALS_NO_ADDR_SPACE (ttr
)
5427 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl
))
5429 /* Types differing only by the presence of the 'volatile'
5430 qualifier are acceptable if the 'volatile' has been added
5431 in by the Objective-C EH machinery. */
5432 if (!objc_type_quals_match (ttl
, ttr
))
5433 WARN_FOR_QUALIFIERS (location
, 0,
5434 G_("passing argument %d of %qE discards "
5435 "%qv qualifier from pointer target type"),
5436 G_("assignment discards %qv qualifier "
5437 "from pointer target type"),
5438 G_("initialization discards %qv qualifier "
5439 "from pointer target type"),
5440 G_("return discards %qv qualifier from "
5441 "pointer target type"),
5442 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
5444 /* If this is not a case of ignoring a mismatch in signedness,
5446 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
5449 /* If there is a mismatch, do warn. */
5450 else if (warn_pointer_sign
)
5451 WARN_FOR_ASSIGNMENT (location
, OPT_Wpointer_sign
,
5452 G_("pointer targets in passing argument "
5453 "%d of %qE differ in signedness"),
5454 G_("pointer targets in assignment "
5455 "differ in signedness"),
5456 G_("pointer targets in initialization "
5457 "differ in signedness"),
5458 G_("pointer targets in return differ "
5461 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
5462 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
5464 /* Because const and volatile on functions are restrictions
5465 that say the function will not do certain things,
5466 it is okay to use a const or volatile function
5467 where an ordinary one is wanted, but not vice-versa. */
5468 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
5469 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
5470 WARN_FOR_QUALIFIERS (location
, 0,
5471 G_("passing argument %d of %qE makes "
5472 "%q#v qualified function pointer "
5473 "from unqualified"),
5474 G_("assignment makes %q#v qualified function "
5475 "pointer from unqualified"),
5476 G_("initialization makes %q#v qualified "
5477 "function pointer from unqualified"),
5478 G_("return makes %q#v qualified function "
5479 "pointer from unqualified"),
5480 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
5484 /* Avoid warning about the volatile ObjC EH puts on decls. */
5486 WARN_FOR_ASSIGNMENT (location
, 0,
5487 G_("passing argument %d of %qE from "
5488 "incompatible pointer type"),
5489 G_("assignment from incompatible pointer type"),
5490 G_("initialization from incompatible "
5492 G_("return from incompatible pointer type"));
5494 return convert (type
, rhs
);
5496 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
5498 /* ??? This should not be an error when inlining calls to
5499 unprototyped functions. */
5500 error_at (location
, "invalid use of non-lvalue array");
5501 return error_mark_node
;
5503 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
5505 /* An explicit constant 0 can convert to a pointer,
5506 or one that results from arithmetic, even including
5507 a cast to integer type. */
5508 if (!null_pointer_constant
)
5509 WARN_FOR_ASSIGNMENT (location
, 0,
5510 G_("passing argument %d of %qE makes "
5511 "pointer from integer without a cast"),
5512 G_("assignment makes pointer from integer "
5514 G_("initialization makes pointer from "
5515 "integer without a cast"),
5516 G_("return makes pointer from integer "
5519 return convert (type
, rhs
);
5521 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
5523 WARN_FOR_ASSIGNMENT (location
, 0,
5524 G_("passing argument %d of %qE makes integer "
5525 "from pointer without a cast"),
5526 G_("assignment makes integer from pointer "
5528 G_("initialization makes integer from pointer "
5530 G_("return makes integer from pointer "
5532 return convert (type
, rhs
);
5534 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
5537 bool save
= in_late_binary_op
;
5538 in_late_binary_op
= true;
5539 ret
= convert (type
, rhs
);
5540 in_late_binary_op
= save
;
5547 error_at (location
, "incompatible type for argument %d of %qE", parmnum
, rname
);
5548 inform ((fundecl
&& !DECL_IS_BUILTIN (fundecl
))
5549 ? DECL_SOURCE_LOCATION (fundecl
) : input_location
,
5550 "expected %qT but argument is of type %qT", type
, rhstype
);
5553 error_at (location
, "incompatible types when assigning to type %qT from "
5554 "type %qT", type
, rhstype
);
5558 "incompatible types when initializing type %qT using type %qT",
5563 "incompatible types when returning type %qT but %qT was "
5564 "expected", rhstype
, type
);
5570 return error_mark_node
;
5573 /* If VALUE is a compound expr all of whose expressions are constant, then
5574 return its value. Otherwise, return error_mark_node.
5576 This is for handling COMPOUND_EXPRs as initializer elements
5577 which is allowed with a warning when -pedantic is specified. */
5580 valid_compound_expr_initializer (tree value
, tree endtype
)
5582 if (TREE_CODE (value
) == COMPOUND_EXPR
)
5584 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
5586 return error_mark_node
;
5587 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
5590 else if (!initializer_constant_valid_p (value
, endtype
))
5591 return error_mark_node
;
5596 /* Perform appropriate conversions on the initial value of a variable,
5597 store it in the declaration DECL,
5598 and print any error messages that are appropriate.
5599 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5600 If the init is invalid, store an ERROR_MARK.
5602 INIT_LOC is the location of the initial value. */
5605 store_init_value (location_t init_loc
, tree decl
, tree init
, tree origtype
)
5610 /* If variable's type was invalidly declared, just ignore it. */
5612 type
= TREE_TYPE (decl
);
5613 if (TREE_CODE (type
) == ERROR_MARK
)
5616 /* Digest the specified initializer into an expression. */
5619 npc
= null_pointer_constant_p (init
);
5620 value
= digest_init (init_loc
, type
, init
, origtype
, npc
,
5621 true, TREE_STATIC (decl
));
5623 /* Store the expression if valid; else report error. */
5625 if (!in_system_header
5626 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
5627 warning (OPT_Wtraditional
, "traditional C rejects automatic "
5628 "aggregate initialization");
5630 DECL_INITIAL (decl
) = value
;
5632 /* ANSI wants warnings about out-of-range constant initializers. */
5633 STRIP_TYPE_NOPS (value
);
5634 if (TREE_STATIC (decl
))
5635 constant_expression_warning (value
);
5637 /* Check if we need to set array size from compound literal size. */
5638 if (TREE_CODE (type
) == ARRAY_TYPE
5639 && TYPE_DOMAIN (type
) == 0
5640 && value
!= error_mark_node
)
5642 tree inside_init
= init
;
5644 STRIP_TYPE_NOPS (inside_init
);
5645 inside_init
= fold (inside_init
);
5647 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
5649 tree cldecl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
5651 if (TYPE_DOMAIN (TREE_TYPE (cldecl
)))
5653 /* For int foo[] = (int [3]){1}; we need to set array size
5654 now since later on array initializer will be just the
5655 brace enclosed list of the compound literal. */
5656 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5657 TREE_TYPE (decl
) = type
;
5658 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (cldecl
));
5660 layout_decl (cldecl
, 0);
5666 /* Methods for storing and printing names for error messages. */
5668 /* Implement a spelling stack that allows components of a name to be pushed
5669 and popped. Each element on the stack is this structure. */
5676 unsigned HOST_WIDE_INT i
;
5681 #define SPELLING_STRING 1
5682 #define SPELLING_MEMBER 2
5683 #define SPELLING_BOUNDS 3
5685 static struct spelling
*spelling
; /* Next stack element (unused). */
5686 static struct spelling
*spelling_base
; /* Spelling stack base. */
5687 static int spelling_size
; /* Size of the spelling stack. */
5689 /* Macros to save and restore the spelling stack around push_... functions.
5690 Alternative to SAVE_SPELLING_STACK. */
5692 #define SPELLING_DEPTH() (spelling - spelling_base)
5693 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
5695 /* Push an element on the spelling stack with type KIND and assign VALUE
5698 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
5700 int depth = SPELLING_DEPTH (); \
5702 if (depth >= spelling_size) \
5704 spelling_size += 10; \
5705 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
5707 RESTORE_SPELLING_DEPTH (depth); \
5710 spelling->kind = (KIND); \
5711 spelling->MEMBER = (VALUE); \
5715 /* Push STRING on the stack. Printed literally. */
5718 push_string (const char *string
)
5720 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
5723 /* Push a member name on the stack. Printed as '.' STRING. */
5726 push_member_name (tree decl
)
5728 const char *const string
5730 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)))
5731 : _("<anonymous>"));
5732 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
5735 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
5738 push_array_bounds (unsigned HOST_WIDE_INT bounds
)
5740 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
5743 /* Compute the maximum size in bytes of the printed spelling. */
5746 spelling_length (void)
5751 for (p
= spelling_base
; p
< spelling
; p
++)
5753 if (p
->kind
== SPELLING_BOUNDS
)
5756 size
+= strlen (p
->u
.s
) + 1;
5762 /* Print the spelling to BUFFER and return it. */
5765 print_spelling (char *buffer
)
5770 for (p
= spelling_base
; p
< spelling
; p
++)
5771 if (p
->kind
== SPELLING_BOUNDS
)
5773 sprintf (d
, "[" HOST_WIDE_INT_PRINT_UNSIGNED
"]", p
->u
.i
);
5779 if (p
->kind
== SPELLING_MEMBER
)
5781 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
5788 /* Issue an error message for a bad initializer component.
5789 GMSGID identifies the message.
5790 The component name is taken from the spelling stack. */
5793 error_init (const char *gmsgid
)
5797 /* The gmsgid may be a format string with %< and %>. */
5799 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5801 error ("(near initialization for %qs)", ofwhat
);
5804 /* Issue a pedantic warning for a bad initializer component. OPT is
5805 the option OPT_* (from options.h) controlling this warning or 0 if
5806 it is unconditionally given. GMSGID identifies the message. The
5807 component name is taken from the spelling stack. */
5810 pedwarn_init (location_t location
, int opt
, const char *gmsgid
)
5814 /* The gmsgid may be a format string with %< and %>. */
5815 pedwarn (location
, opt
, gmsgid
);
5816 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5818 pedwarn (location
, opt
, "(near initialization for %qs)", ofwhat
);
5821 /* Issue a warning for a bad initializer component.
5823 OPT is the OPT_W* value corresponding to the warning option that
5824 controls this warning. GMSGID identifies the message. The
5825 component name is taken from the spelling stack. */
5828 warning_init (int opt
, const char *gmsgid
)
5832 /* The gmsgid may be a format string with %< and %>. */
5833 warning (opt
, gmsgid
);
5834 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5836 warning (opt
, "(near initialization for %qs)", ofwhat
);
5839 /* If TYPE is an array type and EXPR is a parenthesized string
5840 constant, warn if pedantic that EXPR is being used to initialize an
5841 object of type TYPE. */
5844 maybe_warn_string_init (tree type
, struct c_expr expr
)
5847 && TREE_CODE (type
) == ARRAY_TYPE
5848 && TREE_CODE (expr
.value
) == STRING_CST
5849 && expr
.original_code
!= STRING_CST
)
5850 pedwarn_init (input_location
, OPT_pedantic
,
5851 "array initialized from parenthesized string constant");
5854 /* Digest the parser output INIT as an initializer for type TYPE.
5855 Return a C expression of type TYPE to represent the initial value.
5857 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5859 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
5861 If INIT is a string constant, STRICT_STRING is true if it is
5862 unparenthesized or we should not warn here for it being parenthesized.
5863 For other types of INIT, STRICT_STRING is not used.
5865 INIT_LOC is the location of the INIT.
5867 REQUIRE_CONSTANT requests an error if non-constant initializers or
5868 elements are seen. */
5871 digest_init (location_t init_loc
, tree type
, tree init
, tree origtype
,
5872 bool null_pointer_constant
, bool strict_string
,
5873 int require_constant
)
5875 enum tree_code code
= TREE_CODE (type
);
5876 tree inside_init
= init
;
5877 tree semantic_type
= NULL_TREE
;
5878 bool maybe_const
= true;
5880 if (type
== error_mark_node
5882 || init
== error_mark_node
5883 || TREE_TYPE (init
) == error_mark_node
)
5884 return error_mark_node
;
5886 STRIP_TYPE_NOPS (inside_init
);
5888 if (TREE_CODE (inside_init
) == EXCESS_PRECISION_EXPR
)
5890 semantic_type
= TREE_TYPE (inside_init
);
5891 inside_init
= TREE_OPERAND (inside_init
, 0);
5893 inside_init
= c_fully_fold (inside_init
, require_constant
, &maybe_const
);
5894 inside_init
= decl_constant_value_for_optimization (inside_init
);
5896 /* Initialization of an array of chars from a string constant
5897 optionally enclosed in braces. */
5899 if (code
== ARRAY_TYPE
&& inside_init
5900 && TREE_CODE (inside_init
) == STRING_CST
)
5902 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
5903 /* Note that an array could be both an array of character type
5904 and an array of wchar_t if wchar_t is signed char or unsigned
5906 bool char_array
= (typ1
== char_type_node
5907 || typ1
== signed_char_type_node
5908 || typ1
== unsigned_char_type_node
);
5909 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
5910 bool char16_array
= !!comptypes (typ1
, char16_type_node
);
5911 bool char32_array
= !!comptypes (typ1
, char32_type_node
);
5913 if (char_array
|| wchar_array
|| char16_array
|| char32_array
)
5916 tree typ2
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)));
5917 expr
.value
= inside_init
;
5918 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
5919 expr
.original_type
= NULL
;
5920 maybe_warn_string_init (type
, expr
);
5922 if (TYPE_DOMAIN (type
) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
5923 pedwarn_init (init_loc
, OPT_pedantic
,
5924 "initialization of a flexible array member");
5926 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
5927 TYPE_MAIN_VARIANT (type
)))
5932 if (typ2
!= char_type_node
)
5934 error_init ("char-array initialized from wide string");
5935 return error_mark_node
;
5940 if (typ2
== char_type_node
)
5942 error_init ("wide character array initialized from non-wide "
5944 return error_mark_node
;
5946 else if (!comptypes(typ1
, typ2
))
5948 error_init ("wide character array initialized from "
5949 "incompatible wide string");
5950 return error_mark_node
;
5954 TREE_TYPE (inside_init
) = type
;
5955 if (TYPE_DOMAIN (type
) != 0
5956 && TYPE_SIZE (type
) != 0
5957 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
5959 unsigned HOST_WIDE_INT len
= TREE_STRING_LENGTH (inside_init
);
5961 /* Subtract the size of a single (possibly wide) character
5962 because it's ok to ignore the terminating null char
5963 that is counted in the length of the constant. */
5964 if (0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
5966 - (TYPE_PRECISION (typ1
)
5968 pedwarn_init (init_loc
, 0,
5969 ("initializer-string for array of chars "
5971 else if (warn_cxx_compat
5972 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
), len
))
5973 warning_at (init_loc
, OPT_Wc___compat
,
5974 ("initializer-string for array chars "
5975 "is too long for C++"));
5980 else if (INTEGRAL_TYPE_P (typ1
))
5982 error_init ("array of inappropriate type initialized "
5983 "from string constant");
5984 return error_mark_node
;
5988 /* Build a VECTOR_CST from a *constant* vector constructor. If the
5989 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
5990 below and handle as a constructor. */
5991 if (code
== VECTOR_TYPE
5992 && TREE_CODE (TREE_TYPE (inside_init
)) == VECTOR_TYPE
5993 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
, true)
5994 && TREE_CONSTANT (inside_init
))
5996 if (TREE_CODE (inside_init
) == VECTOR_CST
5997 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
5998 TYPE_MAIN_VARIANT (type
)))
6001 if (TREE_CODE (inside_init
) == CONSTRUCTOR
)
6003 unsigned HOST_WIDE_INT ix
;
6005 bool constant_p
= true;
6007 /* Iterate through elements and check if all constructor
6008 elements are *_CSTs. */
6009 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init
), ix
, value
)
6010 if (!CONSTANT_CLASS_P (value
))
6017 return build_vector_from_ctor (type
,
6018 CONSTRUCTOR_ELTS (inside_init
));
6022 if (warn_sequence_point
)
6023 verify_sequence_points (inside_init
);
6025 /* Any type can be initialized
6026 from an expression of the same type, optionally with braces. */
6028 if (inside_init
&& TREE_TYPE (inside_init
) != 0
6029 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
6030 TYPE_MAIN_VARIANT (type
))
6031 || (code
== ARRAY_TYPE
6032 && comptypes (TREE_TYPE (inside_init
), type
))
6033 || (code
== VECTOR_TYPE
6034 && comptypes (TREE_TYPE (inside_init
), type
))
6035 || (code
== POINTER_TYPE
6036 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
6037 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
6038 TREE_TYPE (type
)))))
6040 if (code
== POINTER_TYPE
)
6042 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
6044 if (TREE_CODE (inside_init
) == STRING_CST
6045 || TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6046 inside_init
= array_to_pointer_conversion
6047 (init_loc
, inside_init
);
6050 error_init ("invalid use of non-lvalue array");
6051 return error_mark_node
;
6056 if (code
== VECTOR_TYPE
)
6057 /* Although the types are compatible, we may require a
6059 inside_init
= convert (type
, inside_init
);
6061 if (require_constant
6062 && (code
== VECTOR_TYPE
|| !flag_isoc99
)
6063 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6065 /* As an extension, allow initializing objects with static storage
6066 duration with compound literals (which are then treated just as
6067 the brace enclosed list they contain). Also allow this for
6068 vectors, as we can only assign them with compound literals. */
6069 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
6070 inside_init
= DECL_INITIAL (decl
);
6073 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
6074 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
6076 error_init ("array initialized from non-constant array expression");
6077 return error_mark_node
;
6080 /* Compound expressions can only occur here if -pedantic or
6081 -pedantic-errors is specified. In the later case, we always want
6082 an error. In the former case, we simply want a warning. */
6083 if (require_constant
&& pedantic
6084 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
6087 = valid_compound_expr_initializer (inside_init
,
6088 TREE_TYPE (inside_init
));
6089 if (inside_init
== error_mark_node
)
6090 error_init ("initializer element is not constant");
6092 pedwarn_init (init_loc
, OPT_pedantic
,
6093 "initializer element is not constant");
6094 if (flag_pedantic_errors
)
6095 inside_init
= error_mark_node
;
6097 else if (require_constant
6098 && !initializer_constant_valid_p (inside_init
,
6099 TREE_TYPE (inside_init
)))
6101 error_init ("initializer element is not constant");
6102 inside_init
= error_mark_node
;
6104 else if (require_constant
&& !maybe_const
)
6105 pedwarn_init (init_loc
, 0,
6106 "initializer element is not a constant expression");
6108 /* Added to enable additional -Wmissing-format-attribute warnings. */
6109 if (TREE_CODE (TREE_TYPE (inside_init
)) == POINTER_TYPE
)
6110 inside_init
= convert_for_assignment (init_loc
, type
, inside_init
,
6112 ic_init
, null_pointer_constant
,
6113 NULL_TREE
, NULL_TREE
, 0);
6117 /* Handle scalar types, including conversions. */
6119 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
6120 || code
== POINTER_TYPE
|| code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
6121 || code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
6123 if (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
6124 && (TREE_CODE (init
) == STRING_CST
6125 || TREE_CODE (init
) == COMPOUND_LITERAL_EXPR
))
6126 inside_init
= init
= array_to_pointer_conversion (init_loc
, init
);
6128 inside_init
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
6131 = convert_for_assignment (init_loc
, type
, inside_init
, origtype
,
6132 ic_init
, null_pointer_constant
,
6133 NULL_TREE
, NULL_TREE
, 0);
6135 /* Check to see if we have already given an error message. */
6136 if (inside_init
== error_mark_node
)
6138 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
6140 error_init ("initializer element is not constant");
6141 inside_init
= error_mark_node
;
6143 else if (require_constant
6144 && !initializer_constant_valid_p (inside_init
,
6145 TREE_TYPE (inside_init
)))
6147 error_init ("initializer element is not computable at load time");
6148 inside_init
= error_mark_node
;
6150 else if (require_constant
&& !maybe_const
)
6151 pedwarn_init (init_loc
, 0,
6152 "initializer element is not a constant expression");
6157 /* Come here only for records and arrays. */
6159 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
6161 error_init ("variable-sized object may not be initialized");
6162 return error_mark_node
;
6165 error_init ("invalid initializer");
6166 return error_mark_node
;
6169 /* Handle initializers that use braces. */
6171 /* Type of object we are accumulating a constructor for.
6172 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
6173 static tree constructor_type
;
6175 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
6177 static tree constructor_fields
;
6179 /* For an ARRAY_TYPE, this is the specified index
6180 at which to store the next element we get. */
6181 static tree constructor_index
;
6183 /* For an ARRAY_TYPE, this is the maximum index. */
6184 static tree constructor_max_index
;
6186 /* For a RECORD_TYPE, this is the first field not yet written out. */
6187 static tree constructor_unfilled_fields
;
6189 /* For an ARRAY_TYPE, this is the index of the first element
6190 not yet written out. */
6191 static tree constructor_unfilled_index
;
6193 /* In a RECORD_TYPE, the byte index of the next consecutive field.
6194 This is so we can generate gaps between fields, when appropriate. */
6195 static tree constructor_bit_index
;
6197 /* If we are saving up the elements rather than allocating them,
6198 this is the list of elements so far (in reverse order,
6199 most recent first). */
6200 static VEC(constructor_elt
,gc
) *constructor_elements
;
6202 /* 1 if constructor should be incrementally stored into a constructor chain,
6203 0 if all the elements should be kept in AVL tree. */
6204 static int constructor_incremental
;
6206 /* 1 if so far this constructor's elements are all compile-time constants. */
6207 static int constructor_constant
;
6209 /* 1 if so far this constructor's elements are all valid address constants. */
6210 static int constructor_simple
;
6212 /* 1 if this constructor has an element that cannot be part of a
6213 constant expression. */
6214 static int constructor_nonconst
;
6216 /* 1 if this constructor is erroneous so far. */
6217 static int constructor_erroneous
;
6219 /* Structure for managing pending initializer elements, organized as an
6224 struct init_node
*left
, *right
;
6225 struct init_node
*parent
;
6232 /* Tree of pending elements at this constructor level.
6233 These are elements encountered out of order
6234 which belong at places we haven't reached yet in actually
6236 Will never hold tree nodes across GC runs. */
6237 static struct init_node
*constructor_pending_elts
;
6239 /* The SPELLING_DEPTH of this constructor. */
6240 static int constructor_depth
;
6242 /* DECL node for which an initializer is being read.
6243 0 means we are reading a constructor expression
6244 such as (struct foo) {...}. */
6245 static tree constructor_decl
;
6247 /* Nonzero if this is an initializer for a top-level decl. */
6248 static int constructor_top_level
;
6250 /* Nonzero if there were any member designators in this initializer. */
6251 static int constructor_designated
;
6253 /* Nesting depth of designator list. */
6254 static int designator_depth
;
6256 /* Nonzero if there were diagnosed errors in this designator list. */
6257 static int designator_erroneous
;
6260 /* This stack has a level for each implicit or explicit level of
6261 structuring in the initializer, including the outermost one. It
6262 saves the values of most of the variables above. */
6264 struct constructor_range_stack
;
6266 struct constructor_stack
6268 struct constructor_stack
*next
;
6273 tree unfilled_index
;
6274 tree unfilled_fields
;
6276 VEC(constructor_elt
,gc
) *elements
;
6277 struct init_node
*pending_elts
;
6280 /* If value nonzero, this value should replace the entire
6281 constructor at this level. */
6282 struct c_expr replacement_value
;
6283 struct constructor_range_stack
*range_stack
;
6294 static struct constructor_stack
*constructor_stack
;
6296 /* This stack represents designators from some range designator up to
6297 the last designator in the list. */
6299 struct constructor_range_stack
6301 struct constructor_range_stack
*next
, *prev
;
6302 struct constructor_stack
*stack
;
6309 static struct constructor_range_stack
*constructor_range_stack
;
6311 /* This stack records separate initializers that are nested.
6312 Nested initializers can't happen in ANSI C, but GNU C allows them
6313 in cases like { ... (struct foo) { ... } ... }. */
6315 struct initializer_stack
6317 struct initializer_stack
*next
;
6319 struct constructor_stack
*constructor_stack
;
6320 struct constructor_range_stack
*constructor_range_stack
;
6321 VEC(constructor_elt
,gc
) *elements
;
6322 struct spelling
*spelling
;
6323 struct spelling
*spelling_base
;
6326 char require_constant_value
;
6327 char require_constant_elements
;
6330 static struct initializer_stack
*initializer_stack
;
6332 /* Prepare to parse and output the initializer for variable DECL. */
6335 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
)
6338 struct initializer_stack
*p
= XNEW (struct initializer_stack
);
6340 p
->decl
= constructor_decl
;
6341 p
->require_constant_value
= require_constant_value
;
6342 p
->require_constant_elements
= require_constant_elements
;
6343 p
->constructor_stack
= constructor_stack
;
6344 p
->constructor_range_stack
= constructor_range_stack
;
6345 p
->elements
= constructor_elements
;
6346 p
->spelling
= spelling
;
6347 p
->spelling_base
= spelling_base
;
6348 p
->spelling_size
= spelling_size
;
6349 p
->top_level
= constructor_top_level
;
6350 p
->next
= initializer_stack
;
6351 initializer_stack
= p
;
6353 constructor_decl
= decl
;
6354 constructor_designated
= 0;
6355 constructor_top_level
= top_level
;
6357 if (decl
!= 0 && decl
!= error_mark_node
)
6359 require_constant_value
= TREE_STATIC (decl
);
6360 require_constant_elements
6361 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
6362 /* For a scalar, you can always use any value to initialize,
6363 even within braces. */
6364 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
6365 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6366 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6367 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
6368 locus
= identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)));
6372 require_constant_value
= 0;
6373 require_constant_elements
= 0;
6374 locus
= _("(anonymous)");
6377 constructor_stack
= 0;
6378 constructor_range_stack
= 0;
6380 missing_braces_mentioned
= 0;
6384 RESTORE_SPELLING_DEPTH (0);
6387 push_string (locus
);
6393 struct initializer_stack
*p
= initializer_stack
;
6395 /* Free the whole constructor stack of this initializer. */
6396 while (constructor_stack
)
6398 struct constructor_stack
*q
= constructor_stack
;
6399 constructor_stack
= q
->next
;
6403 gcc_assert (!constructor_range_stack
);
6405 /* Pop back to the data of the outer initializer (if any). */
6406 free (spelling_base
);
6408 constructor_decl
= p
->decl
;
6409 require_constant_value
= p
->require_constant_value
;
6410 require_constant_elements
= p
->require_constant_elements
;
6411 constructor_stack
= p
->constructor_stack
;
6412 constructor_range_stack
= p
->constructor_range_stack
;
6413 constructor_elements
= p
->elements
;
6414 spelling
= p
->spelling
;
6415 spelling_base
= p
->spelling_base
;
6416 spelling_size
= p
->spelling_size
;
6417 constructor_top_level
= p
->top_level
;
6418 initializer_stack
= p
->next
;
6422 /* Call here when we see the initializer is surrounded by braces.
6423 This is instead of a call to push_init_level;
6424 it is matched by a call to pop_init_level.
6426 TYPE is the type to initialize, for a constructor expression.
6427 For an initializer for a decl, TYPE is zero. */
6430 really_start_incremental_init (tree type
)
6432 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
6435 type
= TREE_TYPE (constructor_decl
);
6437 if (TREE_CODE (type
) == VECTOR_TYPE
6438 && TYPE_VECTOR_OPAQUE (type
))
6439 error ("opaque vector types cannot be initialized");
6441 p
->type
= constructor_type
;
6442 p
->fields
= constructor_fields
;
6443 p
->index
= constructor_index
;
6444 p
->max_index
= constructor_max_index
;
6445 p
->unfilled_index
= constructor_unfilled_index
;
6446 p
->unfilled_fields
= constructor_unfilled_fields
;
6447 p
->bit_index
= constructor_bit_index
;
6448 p
->elements
= constructor_elements
;
6449 p
->constant
= constructor_constant
;
6450 p
->simple
= constructor_simple
;
6451 p
->nonconst
= constructor_nonconst
;
6452 p
->erroneous
= constructor_erroneous
;
6453 p
->pending_elts
= constructor_pending_elts
;
6454 p
->depth
= constructor_depth
;
6455 p
->replacement_value
.value
= 0;
6456 p
->replacement_value
.original_code
= ERROR_MARK
;
6457 p
->replacement_value
.original_type
= NULL
;
6461 p
->incremental
= constructor_incremental
;
6462 p
->designated
= constructor_designated
;
6464 constructor_stack
= p
;
6466 constructor_constant
= 1;
6467 constructor_simple
= 1;
6468 constructor_nonconst
= 0;
6469 constructor_depth
= SPELLING_DEPTH ();
6470 constructor_elements
= 0;
6471 constructor_pending_elts
= 0;
6472 constructor_type
= type
;
6473 constructor_incremental
= 1;
6474 constructor_designated
= 0;
6475 designator_depth
= 0;
6476 designator_erroneous
= 0;
6478 if (TREE_CODE (constructor_type
) == RECORD_TYPE
6479 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6481 constructor_fields
= TYPE_FIELDS (constructor_type
);
6482 /* Skip any nameless bit fields at the beginning. */
6483 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
6484 && DECL_NAME (constructor_fields
) == 0)
6485 constructor_fields
= TREE_CHAIN (constructor_fields
);
6487 constructor_unfilled_fields
= constructor_fields
;
6488 constructor_bit_index
= bitsize_zero_node
;
6490 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6492 if (TYPE_DOMAIN (constructor_type
))
6494 constructor_max_index
6495 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
6497 /* Detect non-empty initializations of zero-length arrays. */
6498 if (constructor_max_index
== NULL_TREE
6499 && TYPE_SIZE (constructor_type
))
6500 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6502 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6503 to initialize VLAs will cause a proper error; avoid tree
6504 checking errors as well by setting a safe value. */
6505 if (constructor_max_index
6506 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
6507 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6510 = convert (bitsizetype
,
6511 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
6515 constructor_index
= bitsize_zero_node
;
6516 constructor_max_index
= NULL_TREE
;
6519 constructor_unfilled_index
= constructor_index
;
6521 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6523 /* Vectors are like simple fixed-size arrays. */
6524 constructor_max_index
=
6525 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
6526 constructor_index
= bitsize_zero_node
;
6527 constructor_unfilled_index
= constructor_index
;
6531 /* Handle the case of int x = {5}; */
6532 constructor_fields
= constructor_type
;
6533 constructor_unfilled_fields
= constructor_type
;
6537 /* Push down into a subobject, for initialization.
6538 If this is for an explicit set of braces, IMPLICIT is 0.
6539 If it is because the next element belongs at a lower level,
6540 IMPLICIT is 1 (or 2 if the push is because of designator list). */
6543 push_init_level (int implicit
, struct obstack
* braced_init_obstack
)
6545 struct constructor_stack
*p
;
6546 tree value
= NULL_TREE
;
6548 /* If we've exhausted any levels that didn't have braces,
6549 pop them now. If implicit == 1, this will have been done in
6550 process_init_element; do not repeat it here because in the case
6551 of excess initializers for an empty aggregate this leads to an
6552 infinite cycle of popping a level and immediately recreating
6556 while (constructor_stack
->implicit
)
6558 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6559 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6560 && constructor_fields
== 0)
6561 process_init_element (pop_init_level (1, braced_init_obstack
),
6562 true, braced_init_obstack
);
6563 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
6564 && constructor_max_index
6565 && tree_int_cst_lt (constructor_max_index
,
6567 process_init_element (pop_init_level (1, braced_init_obstack
),
6568 true, braced_init_obstack
);
6574 /* Unless this is an explicit brace, we need to preserve previous
6578 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6579 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6580 && constructor_fields
)
6581 value
= find_init_member (constructor_fields
, braced_init_obstack
);
6582 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6583 value
= find_init_member (constructor_index
, braced_init_obstack
);
6586 p
= XNEW (struct constructor_stack
);
6587 p
->type
= constructor_type
;
6588 p
->fields
= constructor_fields
;
6589 p
->index
= constructor_index
;
6590 p
->max_index
= constructor_max_index
;
6591 p
->unfilled_index
= constructor_unfilled_index
;
6592 p
->unfilled_fields
= constructor_unfilled_fields
;
6593 p
->bit_index
= constructor_bit_index
;
6594 p
->elements
= constructor_elements
;
6595 p
->constant
= constructor_constant
;
6596 p
->simple
= constructor_simple
;
6597 p
->nonconst
= constructor_nonconst
;
6598 p
->erroneous
= constructor_erroneous
;
6599 p
->pending_elts
= constructor_pending_elts
;
6600 p
->depth
= constructor_depth
;
6601 p
->replacement_value
.value
= 0;
6602 p
->replacement_value
.original_code
= ERROR_MARK
;
6603 p
->replacement_value
.original_type
= NULL
;
6604 p
->implicit
= implicit
;
6606 p
->incremental
= constructor_incremental
;
6607 p
->designated
= constructor_designated
;
6608 p
->next
= constructor_stack
;
6610 constructor_stack
= p
;
6612 constructor_constant
= 1;
6613 constructor_simple
= 1;
6614 constructor_nonconst
= 0;
6615 constructor_depth
= SPELLING_DEPTH ();
6616 constructor_elements
= 0;
6617 constructor_incremental
= 1;
6618 constructor_designated
= 0;
6619 constructor_pending_elts
= 0;
6622 p
->range_stack
= constructor_range_stack
;
6623 constructor_range_stack
= 0;
6624 designator_depth
= 0;
6625 designator_erroneous
= 0;
6628 /* Don't die if an entire brace-pair level is superfluous
6629 in the containing level. */
6630 if (constructor_type
== 0)
6632 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
6633 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6635 /* Don't die if there are extra init elts at the end. */
6636 if (constructor_fields
== 0)
6637 constructor_type
= 0;
6640 constructor_type
= TREE_TYPE (constructor_fields
);
6641 push_member_name (constructor_fields
);
6642 constructor_depth
++;
6645 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6647 constructor_type
= TREE_TYPE (constructor_type
);
6648 push_array_bounds (tree_low_cst (constructor_index
, 1));
6649 constructor_depth
++;
6652 if (constructor_type
== 0)
6654 error_init ("extra brace group at end of initializer");
6655 constructor_fields
= 0;
6656 constructor_unfilled_fields
= 0;
6660 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
6662 constructor_constant
= TREE_CONSTANT (value
);
6663 constructor_simple
= TREE_STATIC (value
);
6664 constructor_nonconst
= CONSTRUCTOR_NON_CONST (value
);
6665 constructor_elements
= CONSTRUCTOR_ELTS (value
);
6666 if (!VEC_empty (constructor_elt
, constructor_elements
)
6667 && (TREE_CODE (constructor_type
) == RECORD_TYPE
6668 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
6669 set_nonincremental_init (braced_init_obstack
);
6672 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
6674 missing_braces_mentioned
= 1;
6675 warning_init (OPT_Wmissing_braces
, "missing braces around initializer");
6678 if (TREE_CODE (constructor_type
) == RECORD_TYPE
6679 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6681 constructor_fields
= TYPE_FIELDS (constructor_type
);
6682 /* Skip any nameless bit fields at the beginning. */
6683 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
6684 && DECL_NAME (constructor_fields
) == 0)
6685 constructor_fields
= TREE_CHAIN (constructor_fields
);
6687 constructor_unfilled_fields
= constructor_fields
;
6688 constructor_bit_index
= bitsize_zero_node
;
6690 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6692 /* Vectors are like simple fixed-size arrays. */
6693 constructor_max_index
=
6694 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
6695 constructor_index
= convert (bitsizetype
, integer_zero_node
);
6696 constructor_unfilled_index
= constructor_index
;
6698 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6700 if (TYPE_DOMAIN (constructor_type
))
6702 constructor_max_index
6703 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
6705 /* Detect non-empty initializations of zero-length arrays. */
6706 if (constructor_max_index
== NULL_TREE
6707 && TYPE_SIZE (constructor_type
))
6708 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6710 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6711 to initialize VLAs will cause a proper error; avoid tree
6712 checking errors as well by setting a safe value. */
6713 if (constructor_max_index
6714 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
6715 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6718 = convert (bitsizetype
,
6719 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
6722 constructor_index
= bitsize_zero_node
;
6724 constructor_unfilled_index
= constructor_index
;
6725 if (value
&& TREE_CODE (value
) == STRING_CST
)
6727 /* We need to split the char/wchar array into individual
6728 characters, so that we don't have to special case it
6730 set_nonincremental_init_from_string (value
, braced_init_obstack
);
6735 if (constructor_type
!= error_mark_node
)
6736 warning_init (0, "braces around scalar initializer");
6737 constructor_fields
= constructor_type
;
6738 constructor_unfilled_fields
= constructor_type
;
6742 /* At the end of an implicit or explicit brace level,
6743 finish up that level of constructor. If a single expression
6744 with redundant braces initialized that level, return the
6745 c_expr structure for that expression. Otherwise, the original_code
6746 element is set to ERROR_MARK.
6747 If we were outputting the elements as they are read, return 0 as the value
6748 from inner levels (process_init_element ignores that),
6749 but return error_mark_node as the value from the outermost level
6750 (that's what we want to put in DECL_INITIAL).
6751 Otherwise, return a CONSTRUCTOR expression as the value. */
6754 pop_init_level (int implicit
, struct obstack
* braced_init_obstack
)
6756 struct constructor_stack
*p
;
6759 ret
.original_code
= ERROR_MARK
;
6760 ret
.original_type
= NULL
;
6764 /* When we come to an explicit close brace,
6765 pop any inner levels that didn't have explicit braces. */
6766 while (constructor_stack
->implicit
)
6768 process_init_element (pop_init_level (1, braced_init_obstack
),
6769 true, braced_init_obstack
);
6771 gcc_assert (!constructor_range_stack
);
6774 /* Now output all pending elements. */
6775 constructor_incremental
= 1;
6776 output_pending_init_elements (1, braced_init_obstack
);
6778 p
= constructor_stack
;
6780 /* Error for initializing a flexible array member, or a zero-length
6781 array member in an inappropriate context. */
6782 if (constructor_type
&& constructor_fields
6783 && TREE_CODE (constructor_type
) == ARRAY_TYPE
6784 && TYPE_DOMAIN (constructor_type
)
6785 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
6787 /* Silently discard empty initializations. The parser will
6788 already have pedwarned for empty brackets. */
6789 if (integer_zerop (constructor_unfilled_index
))
6790 constructor_type
= NULL_TREE
;
6793 gcc_assert (!TYPE_SIZE (constructor_type
));
6795 if (constructor_depth
> 2)
6796 error_init ("initialization of flexible array member in a nested context");
6798 pedwarn_init (input_location
, OPT_pedantic
,
6799 "initialization of a flexible array member");
6801 /* We have already issued an error message for the existence
6802 of a flexible array member not at the end of the structure.
6803 Discard the initializer so that we do not die later. */
6804 if (TREE_CHAIN (constructor_fields
) != NULL_TREE
)
6805 constructor_type
= NULL_TREE
;
6809 /* Warn when some struct elements are implicitly initialized to zero. */
6810 if (warn_missing_field_initializers
6812 && TREE_CODE (constructor_type
) == RECORD_TYPE
6813 && constructor_unfilled_fields
)
6815 /* Do not warn for flexible array members or zero-length arrays. */
6816 while (constructor_unfilled_fields
6817 && (!DECL_SIZE (constructor_unfilled_fields
)
6818 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
6819 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
6821 /* Do not warn if this level of the initializer uses member
6822 designators; it is likely to be deliberate. */
6823 if (constructor_unfilled_fields
&& !constructor_designated
)
6825 push_member_name (constructor_unfilled_fields
);
6826 warning_init (OPT_Wmissing_field_initializers
,
6827 "missing initializer");
6828 RESTORE_SPELLING_DEPTH (constructor_depth
);
6832 /* Pad out the end of the structure. */
6833 if (p
->replacement_value
.value
)
6834 /* If this closes a superfluous brace pair,
6835 just pass out the element between them. */
6836 ret
= p
->replacement_value
;
6837 else if (constructor_type
== 0)
6839 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
6840 && TREE_CODE (constructor_type
) != UNION_TYPE
6841 && TREE_CODE (constructor_type
) != ARRAY_TYPE
6842 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
6844 /* A nonincremental scalar initializer--just return
6845 the element, after verifying there is just one. */
6846 if (VEC_empty (constructor_elt
,constructor_elements
))
6848 if (!constructor_erroneous
)
6849 error_init ("empty scalar initializer");
6850 ret
.value
= error_mark_node
;
6852 else if (VEC_length (constructor_elt
,constructor_elements
) != 1)
6854 error_init ("extra elements in scalar initializer");
6855 ret
.value
= VEC_index (constructor_elt
,constructor_elements
,0)->value
;
6858 ret
.value
= VEC_index (constructor_elt
,constructor_elements
,0)->value
;
6862 if (constructor_erroneous
)
6863 ret
.value
= error_mark_node
;
6866 ret
.value
= build_constructor (constructor_type
,
6867 constructor_elements
);
6868 if (constructor_constant
)
6869 TREE_CONSTANT (ret
.value
) = 1;
6870 if (constructor_constant
&& constructor_simple
)
6871 TREE_STATIC (ret
.value
) = 1;
6872 if (constructor_nonconst
)
6873 CONSTRUCTOR_NON_CONST (ret
.value
) = 1;
6877 if (ret
.value
&& TREE_CODE (ret
.value
) != CONSTRUCTOR
)
6879 if (constructor_nonconst
)
6880 ret
.original_code
= C_MAYBE_CONST_EXPR
;
6881 else if (ret
.original_code
== C_MAYBE_CONST_EXPR
)
6882 ret
.original_code
= ERROR_MARK
;
6885 constructor_type
= p
->type
;
6886 constructor_fields
= p
->fields
;
6887 constructor_index
= p
->index
;
6888 constructor_max_index
= p
->max_index
;
6889 constructor_unfilled_index
= p
->unfilled_index
;
6890 constructor_unfilled_fields
= p
->unfilled_fields
;
6891 constructor_bit_index
= p
->bit_index
;
6892 constructor_elements
= p
->elements
;
6893 constructor_constant
= p
->constant
;
6894 constructor_simple
= p
->simple
;
6895 constructor_nonconst
= p
->nonconst
;
6896 constructor_erroneous
= p
->erroneous
;
6897 constructor_incremental
= p
->incremental
;
6898 constructor_designated
= p
->designated
;
6899 constructor_pending_elts
= p
->pending_elts
;
6900 constructor_depth
= p
->depth
;
6902 constructor_range_stack
= p
->range_stack
;
6903 RESTORE_SPELLING_DEPTH (constructor_depth
);
6905 constructor_stack
= p
->next
;
6908 if (ret
.value
== 0 && constructor_stack
== 0)
6909 ret
.value
= error_mark_node
;
6913 /* Common handling for both array range and field name designators.
6914 ARRAY argument is nonzero for array ranges. Returns zero for success. */
6917 set_designator (int array
, struct obstack
* braced_init_obstack
)
6920 enum tree_code subcode
;
6922 /* Don't die if an entire brace-pair level is superfluous
6923 in the containing level. */
6924 if (constructor_type
== 0)
6927 /* If there were errors in this designator list already, bail out
6929 if (designator_erroneous
)
6932 if (!designator_depth
)
6934 gcc_assert (!constructor_range_stack
);
6936 /* Designator list starts at the level of closest explicit
6938 while (constructor_stack
->implicit
)
6940 process_init_element (pop_init_level (1, braced_init_obstack
),
6941 true, braced_init_obstack
);
6943 constructor_designated
= 1;
6947 switch (TREE_CODE (constructor_type
))
6951 subtype
= TREE_TYPE (constructor_fields
);
6952 if (subtype
!= error_mark_node
)
6953 subtype
= TYPE_MAIN_VARIANT (subtype
);
6956 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6962 subcode
= TREE_CODE (subtype
);
6963 if (array
&& subcode
!= ARRAY_TYPE
)
6965 error_init ("array index in non-array initializer");
6968 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
6970 error_init ("field name not in record or union initializer");
6974 constructor_designated
= 1;
6975 push_init_level (2, braced_init_obstack
);
6979 /* If there are range designators in designator list, push a new designator
6980 to constructor_range_stack. RANGE_END is end of such stack range or
6981 NULL_TREE if there is no range designator at this level. */
6984 push_range_stack (tree range_end
, struct obstack
* braced_init_obstack
)
6986 struct constructor_range_stack
*p
;
6988 p
= (struct constructor_range_stack
*)
6989 obstack_alloc (braced_init_obstack
,
6990 sizeof (struct constructor_range_stack
));
6991 p
->prev
= constructor_range_stack
;
6993 p
->fields
= constructor_fields
;
6994 p
->range_start
= constructor_index
;
6995 p
->index
= constructor_index
;
6996 p
->stack
= constructor_stack
;
6997 p
->range_end
= range_end
;
6998 if (constructor_range_stack
)
6999 constructor_range_stack
->next
= p
;
7000 constructor_range_stack
= p
;
7003 /* Within an array initializer, specify the next index to be initialized.
7004 FIRST is that index. If LAST is nonzero, then initialize a range
7005 of indices, running from FIRST through LAST. */
7008 set_init_index (tree first
, tree last
,
7009 struct obstack
* braced_init_obstack
)
7011 if (set_designator (1, braced_init_obstack
))
7014 designator_erroneous
= 1;
7016 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
7017 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
7019 error_init ("array index in initializer not of integer type");
7023 if (TREE_CODE (first
) != INTEGER_CST
)
7025 first
= c_fully_fold (first
, false, NULL
);
7026 if (TREE_CODE (first
) == INTEGER_CST
)
7027 pedwarn_init (input_location
, OPT_pedantic
,
7028 "array index in initializer is not "
7029 "an integer constant expression");
7032 if (last
&& TREE_CODE (last
) != INTEGER_CST
)
7034 last
= c_fully_fold (last
, false, NULL
);
7035 if (TREE_CODE (last
) == INTEGER_CST
)
7036 pedwarn_init (input_location
, OPT_pedantic
,
7037 "array index in initializer is not "
7038 "an integer constant expression");
7041 if (TREE_CODE (first
) != INTEGER_CST
)
7042 error_init ("nonconstant array index in initializer");
7043 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
7044 error_init ("nonconstant array index in initializer");
7045 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
7046 error_init ("array index in non-array initializer");
7047 else if (tree_int_cst_sgn (first
) == -1)
7048 error_init ("array index in initializer exceeds array bounds");
7049 else if (constructor_max_index
7050 && tree_int_cst_lt (constructor_max_index
, first
))
7051 error_init ("array index in initializer exceeds array bounds");
7054 constant_expression_warning (first
);
7056 constant_expression_warning (last
);
7057 constructor_index
= convert (bitsizetype
, first
);
7061 if (tree_int_cst_equal (first
, last
))
7063 else if (tree_int_cst_lt (last
, first
))
7065 error_init ("empty index range in initializer");
7070 last
= convert (bitsizetype
, last
);
7071 if (constructor_max_index
!= 0
7072 && tree_int_cst_lt (constructor_max_index
, last
))
7074 error_init ("array index range in initializer exceeds array bounds");
7081 designator_erroneous
= 0;
7082 if (constructor_range_stack
|| last
)
7083 push_range_stack (last
, braced_init_obstack
);
7087 /* Within a struct initializer, specify the next field to be initialized. */
7090 set_init_label (tree fieldname
, struct obstack
* braced_init_obstack
)
7094 if (set_designator (0, braced_init_obstack
))
7097 designator_erroneous
= 1;
7099 if (TREE_CODE (constructor_type
) != RECORD_TYPE
7100 && TREE_CODE (constructor_type
) != UNION_TYPE
)
7102 error_init ("field name not in record or union initializer");
7106 field
= lookup_field (constructor_type
, fieldname
);
7109 error ("unknown field %qE specified in initializer", fieldname
);
7113 constructor_fields
= TREE_VALUE (field
);
7115 designator_erroneous
= 0;
7116 if (constructor_range_stack
)
7117 push_range_stack (NULL_TREE
, braced_init_obstack
);
7118 field
= TREE_CHAIN (field
);
7121 if (set_designator (0, braced_init_obstack
))
7125 while (field
!= NULL_TREE
);
7128 /* Add a new initializer to the tree of pending initializers. PURPOSE
7129 identifies the initializer, either array index or field in a structure.
7130 VALUE is the value of that index or field. If ORIGTYPE is not
7131 NULL_TREE, it is the original type of VALUE.
7133 IMPLICIT is true if value comes from pop_init_level (1),
7134 the new initializer has been merged with the existing one
7135 and thus no warnings should be emitted about overriding an
7136 existing initializer. */
7139 add_pending_init (tree purpose
, tree value
, tree origtype
, bool implicit
,
7140 struct obstack
* braced_init_obstack
)
7142 struct init_node
*p
, **q
, *r
;
7144 q
= &constructor_pending_elts
;
7147 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7152 if (tree_int_cst_lt (purpose
, p
->purpose
))
7154 else if (tree_int_cst_lt (p
->purpose
, purpose
))
7160 if (TREE_SIDE_EFFECTS (p
->value
))
7161 warning_init (0, "initialized field with side-effects overwritten");
7162 else if (warn_override_init
)
7163 warning_init (OPT_Woverride_init
, "initialized field overwritten");
7166 p
->origtype
= origtype
;
7175 bitpos
= bit_position (purpose
);
7179 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
7181 else if (p
->purpose
!= purpose
)
7187 if (TREE_SIDE_EFFECTS (p
->value
))
7188 warning_init (0, "initialized field with side-effects overwritten");
7189 else if (warn_override_init
)
7190 warning_init (OPT_Woverride_init
, "initialized field overwritten");
7193 p
->origtype
= origtype
;
7199 r
= (struct init_node
*) obstack_alloc (braced_init_obstack
,
7200 sizeof (struct init_node
));
7201 r
->purpose
= purpose
;
7203 r
->origtype
= origtype
;
7213 struct init_node
*s
;
7217 if (p
->balance
== 0)
7219 else if (p
->balance
< 0)
7226 p
->left
->parent
= p
;
7243 constructor_pending_elts
= r
;
7248 struct init_node
*t
= r
->right
;
7252 r
->right
->parent
= r
;
7257 p
->left
->parent
= p
;
7260 p
->balance
= t
->balance
< 0;
7261 r
->balance
= -(t
->balance
> 0);
7276 constructor_pending_elts
= t
;
7282 /* p->balance == +1; growth of left side balances the node. */
7287 else /* r == p->right */
7289 if (p
->balance
== 0)
7290 /* Growth propagation from right side. */
7292 else if (p
->balance
> 0)
7299 p
->right
->parent
= p
;
7316 constructor_pending_elts
= r
;
7318 else /* r->balance == -1 */
7321 struct init_node
*t
= r
->left
;
7325 r
->left
->parent
= r
;
7330 p
->right
->parent
= p
;
7333 r
->balance
= (t
->balance
< 0);
7334 p
->balance
= -(t
->balance
> 0);
7349 constructor_pending_elts
= t
;
7355 /* p->balance == -1; growth of right side balances the node. */
7366 /* Build AVL tree from a sorted chain. */
7369 set_nonincremental_init (struct obstack
* braced_init_obstack
)
7371 unsigned HOST_WIDE_INT ix
;
7374 if (TREE_CODE (constructor_type
) != RECORD_TYPE
7375 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
7378 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements
, ix
, index
, value
)
7380 add_pending_init (index
, value
, NULL_TREE
, false,
7381 braced_init_obstack
);
7383 constructor_elements
= 0;
7384 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7386 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
7387 /* Skip any nameless bit fields at the beginning. */
7388 while (constructor_unfilled_fields
!= 0
7389 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
7390 && DECL_NAME (constructor_unfilled_fields
) == 0)
7391 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
7394 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7396 if (TYPE_DOMAIN (constructor_type
))
7397 constructor_unfilled_index
7398 = convert (bitsizetype
,
7399 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
7401 constructor_unfilled_index
= bitsize_zero_node
;
7403 constructor_incremental
= 0;
7406 /* Build AVL tree from a string constant. */
7409 set_nonincremental_init_from_string (tree str
,
7410 struct obstack
* braced_init_obstack
)
7412 tree value
, purpose
, type
;
7413 HOST_WIDE_INT val
[2];
7414 const char *p
, *end
;
7415 int byte
, wchar_bytes
, charwidth
, bitpos
;
7417 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
7419 wchar_bytes
= TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
))) / BITS_PER_UNIT
;
7420 charwidth
= TYPE_PRECISION (char_type_node
);
7421 type
= TREE_TYPE (constructor_type
);
7422 p
= TREE_STRING_POINTER (str
);
7423 end
= p
+ TREE_STRING_LENGTH (str
);
7425 for (purpose
= bitsize_zero_node
;
7426 p
< end
&& !tree_int_cst_lt (constructor_max_index
, purpose
);
7427 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
7429 if (wchar_bytes
== 1)
7431 val
[1] = (unsigned char) *p
++;
7438 for (byte
= 0; byte
< wchar_bytes
; byte
++)
7440 if (BYTES_BIG_ENDIAN
)
7441 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
7443 bitpos
= byte
* charwidth
;
7444 val
[bitpos
< HOST_BITS_PER_WIDE_INT
]
7445 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
7446 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
7450 if (!TYPE_UNSIGNED (type
))
7452 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
7453 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
7455 if (val
[1] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
7457 val
[1] |= ((HOST_WIDE_INT
) -1) << bitpos
;
7461 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
7466 else if (val
[0] & (((HOST_WIDE_INT
) 1)
7467 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
7468 val
[0] |= ((HOST_WIDE_INT
) -1)
7469 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
7472 value
= build_int_cst_wide (type
, val
[1], val
[0]);
7473 add_pending_init (purpose
, value
, NULL_TREE
, false,
7474 braced_init_obstack
);
7477 constructor_incremental
= 0;
7480 /* Return value of FIELD in pending initializer or zero if the field was
7481 not initialized yet. */
7484 find_init_member (tree field
, struct obstack
* braced_init_obstack
)
7486 struct init_node
*p
;
7488 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7490 if (constructor_incremental
7491 && tree_int_cst_lt (field
, constructor_unfilled_index
))
7492 set_nonincremental_init (braced_init_obstack
);
7494 p
= constructor_pending_elts
;
7497 if (tree_int_cst_lt (field
, p
->purpose
))
7499 else if (tree_int_cst_lt (p
->purpose
, field
))
7505 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7507 tree bitpos
= bit_position (field
);
7509 if (constructor_incremental
7510 && (!constructor_unfilled_fields
7511 || tree_int_cst_lt (bitpos
,
7512 bit_position (constructor_unfilled_fields
))))
7513 set_nonincremental_init (braced_init_obstack
);
7515 p
= constructor_pending_elts
;
7518 if (field
== p
->purpose
)
7520 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
7526 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
7528 if (!VEC_empty (constructor_elt
, constructor_elements
)
7529 && (VEC_last (constructor_elt
, constructor_elements
)->index
7531 return VEC_last (constructor_elt
, constructor_elements
)->value
;
7536 /* "Output" the next constructor element.
7537 At top level, really output it to assembler code now.
7538 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
7539 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
7540 TYPE is the data type that the containing data type wants here.
7541 FIELD is the field (a FIELD_DECL) or the index that this element fills.
7542 If VALUE is a string constant, STRICT_STRING is true if it is
7543 unparenthesized or we should not warn here for it being parenthesized.
7544 For other types of VALUE, STRICT_STRING is not used.
7546 PENDING if non-nil means output pending elements that belong
7547 right after this element. (PENDING is normally 1;
7548 it is 0 while outputting pending elements, to avoid recursion.)
7550 IMPLICIT is true if value comes from pop_init_level (1),
7551 the new initializer has been merged with the existing one
7552 and thus no warnings should be emitted about overriding an
7553 existing initializer. */
7556 output_init_element (tree value
, tree origtype
, bool strict_string
, tree type
,
7557 tree field
, int pending
, bool implicit
,
7558 struct obstack
* braced_init_obstack
)
7560 tree semantic_type
= NULL_TREE
;
7561 constructor_elt
*celt
;
7562 bool maybe_const
= true;
7565 if (type
== error_mark_node
|| value
== error_mark_node
)
7567 constructor_erroneous
= 1;
7570 if (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
7571 && (TREE_CODE (value
) == STRING_CST
7572 || TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
7573 && !(TREE_CODE (value
) == STRING_CST
7574 && TREE_CODE (type
) == ARRAY_TYPE
7575 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
7576 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
7577 TYPE_MAIN_VARIANT (type
)))
7578 value
= array_to_pointer_conversion (input_location
, value
);
7580 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
7581 && require_constant_value
&& !flag_isoc99
&& pending
)
7583 /* As an extension, allow initializing objects with static storage
7584 duration with compound literals (which are then treated just as
7585 the brace enclosed list they contain). */
7586 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
7587 value
= DECL_INITIAL (decl
);
7590 npc
= null_pointer_constant_p (value
);
7591 if (TREE_CODE (value
) == EXCESS_PRECISION_EXPR
)
7593 semantic_type
= TREE_TYPE (value
);
7594 value
= TREE_OPERAND (value
, 0);
7596 value
= c_fully_fold (value
, require_constant_value
, &maybe_const
);
7598 if (value
== error_mark_node
)
7599 constructor_erroneous
= 1;
7600 else if (!TREE_CONSTANT (value
))
7601 constructor_constant
= 0;
7602 else if (!initializer_constant_valid_p (value
, TREE_TYPE (value
))
7603 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
7604 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7605 && DECL_C_BIT_FIELD (field
)
7606 && TREE_CODE (value
) != INTEGER_CST
))
7607 constructor_simple
= 0;
7609 constructor_nonconst
= 1;
7611 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
7613 if (require_constant_value
)
7615 error_init ("initializer element is not constant");
7616 value
= error_mark_node
;
7618 else if (require_constant_elements
)
7619 pedwarn (input_location
, 0,
7620 "initializer element is not computable at load time");
7622 else if (!maybe_const
7623 && (require_constant_value
|| require_constant_elements
))
7624 pedwarn_init (input_location
, 0,
7625 "initializer element is not a constant expression");
7627 /* Issue -Wc++-compat warnings about initializing a bitfield with
7630 && field
!= NULL_TREE
7631 && TREE_CODE (field
) == FIELD_DECL
7632 && DECL_BIT_FIELD_TYPE (field
) != NULL_TREE
7633 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))
7634 != TYPE_MAIN_VARIANT (type
))
7635 && TREE_CODE (DECL_BIT_FIELD_TYPE (field
)) == ENUMERAL_TYPE
)
7637 tree checktype
= origtype
!= NULL_TREE
? origtype
: TREE_TYPE (value
);
7638 if (checktype
!= error_mark_node
7639 && (TYPE_MAIN_VARIANT (checktype
)
7640 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))))
7641 warning_init (OPT_Wc___compat
,
7642 "enum conversion in initialization is invalid in C++");
7645 /* If this field is empty (and not at the end of structure),
7646 don't do anything other than checking the initializer. */
7648 && (TREE_TYPE (field
) == error_mark_node
7649 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
7650 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
7651 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
7652 || TREE_CHAIN (field
)))))
7656 value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, value
);
7657 value
= digest_init (input_location
, type
, value
, origtype
, npc
,
7658 strict_string
, require_constant_value
);
7659 if (value
== error_mark_node
)
7661 constructor_erroneous
= 1;
7664 if (require_constant_value
|| require_constant_elements
)
7665 constant_expression_warning (value
);
7667 /* If this element doesn't come next in sequence,
7668 put it on constructor_pending_elts. */
7669 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
7670 && (!constructor_incremental
7671 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
7673 if (constructor_incremental
7674 && tree_int_cst_lt (field
, constructor_unfilled_index
))
7675 set_nonincremental_init (braced_init_obstack
);
7677 add_pending_init (field
, value
, origtype
, implicit
,
7678 braced_init_obstack
);
7681 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
7682 && (!constructor_incremental
7683 || field
!= constructor_unfilled_fields
))
7685 /* We do this for records but not for unions. In a union,
7686 no matter which field is specified, it can be initialized
7687 right away since it starts at the beginning of the union. */
7688 if (constructor_incremental
)
7690 if (!constructor_unfilled_fields
)
7691 set_nonincremental_init (braced_init_obstack
);
7694 tree bitpos
, unfillpos
;
7696 bitpos
= bit_position (field
);
7697 unfillpos
= bit_position (constructor_unfilled_fields
);
7699 if (tree_int_cst_lt (bitpos
, unfillpos
))
7700 set_nonincremental_init (braced_init_obstack
);
7704 add_pending_init (field
, value
, origtype
, implicit
,
7705 braced_init_obstack
);
7708 else if (TREE_CODE (constructor_type
) == UNION_TYPE
7709 && !VEC_empty (constructor_elt
, constructor_elements
))
7713 if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt
,
7714 constructor_elements
)->value
))
7716 "initialized field with side-effects overwritten");
7717 else if (warn_override_init
)
7718 warning_init (OPT_Woverride_init
, "initialized field overwritten");
7721 /* We can have just one union field set. */
7722 constructor_elements
= 0;
7725 /* Otherwise, output this element either to
7726 constructor_elements or to the assembler file. */
7728 celt
= VEC_safe_push (constructor_elt
, gc
, constructor_elements
, NULL
);
7729 celt
->index
= field
;
7730 celt
->value
= value
;
7732 /* Advance the variable that indicates sequential elements output. */
7733 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7734 constructor_unfilled_index
7735 = size_binop_loc (input_location
, PLUS_EXPR
, constructor_unfilled_index
,
7737 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7739 constructor_unfilled_fields
7740 = TREE_CHAIN (constructor_unfilled_fields
);
7742 /* Skip any nameless bit fields. */
7743 while (constructor_unfilled_fields
!= 0
7744 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
7745 && DECL_NAME (constructor_unfilled_fields
) == 0)
7746 constructor_unfilled_fields
=
7747 TREE_CHAIN (constructor_unfilled_fields
);
7749 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
7750 constructor_unfilled_fields
= 0;
7752 /* Now output any pending elements which have become next. */
7754 output_pending_init_elements (0, braced_init_obstack
);
7757 /* Output any pending elements which have become next.
7758 As we output elements, constructor_unfilled_{fields,index}
7759 advances, which may cause other elements to become next;
7760 if so, they too are output.
7762 If ALL is 0, we return when there are
7763 no more pending elements to output now.
7765 If ALL is 1, we output space as necessary so that
7766 we can output all the pending elements. */
7768 output_pending_init_elements (int all
, struct obstack
* braced_init_obstack
)
7770 struct init_node
*elt
= constructor_pending_elts
;
7775 /* Look through the whole pending tree.
7776 If we find an element that should be output now,
7777 output it. Otherwise, set NEXT to the element
7778 that comes first among those still pending. */
7783 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7785 if (tree_int_cst_equal (elt
->purpose
,
7786 constructor_unfilled_index
))
7787 output_init_element (elt
->value
, elt
->origtype
, true,
7788 TREE_TYPE (constructor_type
),
7789 constructor_unfilled_index
, 0, false,
7790 braced_init_obstack
);
7791 else if (tree_int_cst_lt (constructor_unfilled_index
,
7794 /* Advance to the next smaller node. */
7799 /* We have reached the smallest node bigger than the
7800 current unfilled index. Fill the space first. */
7801 next
= elt
->purpose
;
7807 /* Advance to the next bigger node. */
7812 /* We have reached the biggest node in a subtree. Find
7813 the parent of it, which is the next bigger node. */
7814 while (elt
->parent
&& elt
->parent
->right
== elt
)
7817 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
7820 next
= elt
->purpose
;
7826 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
7827 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7829 tree ctor_unfilled_bitpos
, elt_bitpos
;
7831 /* If the current record is complete we are done. */
7832 if (constructor_unfilled_fields
== 0)
7835 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
7836 elt_bitpos
= bit_position (elt
->purpose
);
7837 /* We can't compare fields here because there might be empty
7838 fields in between. */
7839 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
7841 constructor_unfilled_fields
= elt
->purpose
;
7842 output_init_element (elt
->value
, elt
->origtype
, true,
7843 TREE_TYPE (elt
->purpose
),
7844 elt
->purpose
, 0, false,
7845 braced_init_obstack
);
7847 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
7849 /* Advance to the next smaller node. */
7854 /* We have reached the smallest node bigger than the
7855 current unfilled field. Fill the space first. */
7856 next
= elt
->purpose
;
7862 /* Advance to the next bigger node. */
7867 /* We have reached the biggest node in a subtree. Find
7868 the parent of it, which is the next bigger node. */
7869 while (elt
->parent
&& elt
->parent
->right
== elt
)
7873 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
7874 bit_position (elt
->purpose
))))
7876 next
= elt
->purpose
;
7884 /* Ordinarily return, but not if we want to output all
7885 and there are elements left. */
7886 if (!(all
&& next
!= 0))
7889 /* If it's not incremental, just skip over the gap, so that after
7890 jumping to retry we will output the next successive element. */
7891 if (TREE_CODE (constructor_type
) == RECORD_TYPE
7892 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7893 constructor_unfilled_fields
= next
;
7894 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7895 constructor_unfilled_index
= next
;
7897 /* ELT now points to the node in the pending tree with the next
7898 initializer to output. */
7902 /* Add one non-braced element to the current constructor level.
7903 This adjusts the current position within the constructor's type.
7904 This may also start or terminate implicit levels
7905 to handle a partly-braced initializer.
7907 Once this has found the correct level for the new element,
7908 it calls output_init_element.
7910 IMPLICIT is true if value comes from pop_init_level (1),
7911 the new initializer has been merged with the existing one
7912 and thus no warnings should be emitted about overriding an
7913 existing initializer. */
7916 process_init_element (struct c_expr value
, bool implicit
,
7917 struct obstack
* braced_init_obstack
)
7919 tree orig_value
= value
.value
;
7920 int string_flag
= orig_value
!= 0 && TREE_CODE (orig_value
) == STRING_CST
;
7921 bool strict_string
= value
.original_code
== STRING_CST
;
7923 designator_depth
= 0;
7924 designator_erroneous
= 0;
7926 /* Handle superfluous braces around string cst as in
7927 char x[] = {"foo"}; */
7930 && TREE_CODE (constructor_type
) == ARRAY_TYPE
7931 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
7932 && integer_zerop (constructor_unfilled_index
))
7934 if (constructor_stack
->replacement_value
.value
)
7935 error_init ("excess elements in char array initializer");
7936 constructor_stack
->replacement_value
= value
;
7940 if (constructor_stack
->replacement_value
.value
!= 0)
7942 error_init ("excess elements in struct initializer");
7946 /* Ignore elements of a brace group if it is entirely superfluous
7947 and has already been diagnosed. */
7948 if (constructor_type
== 0)
7951 /* If we've exhausted any levels that didn't have braces,
7953 while (constructor_stack
->implicit
)
7955 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
7956 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7957 && constructor_fields
== 0)
7958 process_init_element (pop_init_level (1, braced_init_obstack
),
7959 true, braced_init_obstack
);
7960 else if ((TREE_CODE (constructor_type
) == ARRAY_TYPE
7961 || TREE_CODE (constructor_type
) == VECTOR_TYPE
)
7962 && (constructor_max_index
== 0
7963 || tree_int_cst_lt (constructor_max_index
,
7964 constructor_index
)))
7965 process_init_element (pop_init_level (1, braced_init_obstack
),
7966 true, braced_init_obstack
);
7971 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
7972 if (constructor_range_stack
)
7974 /* If value is a compound literal and we'll be just using its
7975 content, don't put it into a SAVE_EXPR. */
7976 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
7977 || !require_constant_value
7980 tree semantic_type
= NULL_TREE
;
7981 if (TREE_CODE (value
.value
) == EXCESS_PRECISION_EXPR
)
7983 semantic_type
= TREE_TYPE (value
.value
);
7984 value
.value
= TREE_OPERAND (value
.value
, 0);
7986 value
.value
= c_save_expr (value
.value
);
7988 value
.value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
7995 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7998 enum tree_code fieldcode
;
8000 if (constructor_fields
== 0)
8002 pedwarn_init (input_location
, 0,
8003 "excess elements in struct initializer");
8007 fieldtype
= TREE_TYPE (constructor_fields
);
8008 if (fieldtype
!= error_mark_node
)
8009 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
8010 fieldcode
= TREE_CODE (fieldtype
);
8012 /* Error for non-static initialization of a flexible array member. */
8013 if (fieldcode
== ARRAY_TYPE
8014 && !require_constant_value
8015 && TYPE_SIZE (fieldtype
) == NULL_TREE
8016 && TREE_CHAIN (constructor_fields
) == NULL_TREE
)
8018 error_init ("non-static initialization of a flexible array member");
8022 /* Accept a string constant to initialize a subarray. */
8023 if (value
.value
!= 0
8024 && fieldcode
== ARRAY_TYPE
8025 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
8027 value
.value
= orig_value
;
8028 /* Otherwise, if we have come to a subaggregate,
8029 and we don't have an element of its type, push into it. */
8030 else if (value
.value
!= 0
8031 && value
.value
!= error_mark_node
8032 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
8033 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
8034 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
8036 push_init_level (1, braced_init_obstack
);
8042 push_member_name (constructor_fields
);
8043 output_init_element (value
.value
, value
.original_type
,
8044 strict_string
, fieldtype
,
8045 constructor_fields
, 1, implicit
,
8046 braced_init_obstack
);
8047 RESTORE_SPELLING_DEPTH (constructor_depth
);
8050 /* Do the bookkeeping for an element that was
8051 directly output as a constructor. */
8053 /* For a record, keep track of end position of last field. */
8054 if (DECL_SIZE (constructor_fields
))
8055 constructor_bit_index
8056 = size_binop_loc (input_location
, PLUS_EXPR
,
8057 bit_position (constructor_fields
),
8058 DECL_SIZE (constructor_fields
));
8060 /* If the current field was the first one not yet written out,
8061 it isn't now, so update. */
8062 if (constructor_unfilled_fields
== constructor_fields
)
8064 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
8065 /* Skip any nameless bit fields. */
8066 while (constructor_unfilled_fields
!= 0
8067 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
8068 && DECL_NAME (constructor_unfilled_fields
) == 0)
8069 constructor_unfilled_fields
=
8070 TREE_CHAIN (constructor_unfilled_fields
);
8074 constructor_fields
= TREE_CHAIN (constructor_fields
);
8075 /* Skip any nameless bit fields at the beginning. */
8076 while (constructor_fields
!= 0
8077 && DECL_C_BIT_FIELD (constructor_fields
)
8078 && DECL_NAME (constructor_fields
) == 0)
8079 constructor_fields
= TREE_CHAIN (constructor_fields
);
8081 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
8084 enum tree_code fieldcode
;
8086 if (constructor_fields
== 0)
8088 pedwarn_init (input_location
, 0,
8089 "excess elements in union initializer");
8093 fieldtype
= TREE_TYPE (constructor_fields
);
8094 if (fieldtype
!= error_mark_node
)
8095 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
8096 fieldcode
= TREE_CODE (fieldtype
);
8098 /* Warn that traditional C rejects initialization of unions.
8099 We skip the warning if the value is zero. This is done
8100 under the assumption that the zero initializer in user
8101 code appears conditioned on e.g. __STDC__ to avoid
8102 "missing initializer" warnings and relies on default
8103 initialization to zero in the traditional C case.
8104 We also skip the warning if the initializer is designated,
8105 again on the assumption that this must be conditional on
8106 __STDC__ anyway (and we've already complained about the
8107 member-designator already). */
8108 if (!in_system_header
&& !constructor_designated
8109 && !(value
.value
&& (integer_zerop (value
.value
)
8110 || real_zerop (value
.value
))))
8111 warning (OPT_Wtraditional
, "traditional C rejects initialization "
8114 /* Accept a string constant to initialize a subarray. */
8115 if (value
.value
!= 0
8116 && fieldcode
== ARRAY_TYPE
8117 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
8119 value
.value
= orig_value
;
8120 /* Otherwise, if we have come to a subaggregate,
8121 and we don't have an element of its type, push into it. */
8122 else if (value
.value
!= 0
8123 && value
.value
!= error_mark_node
8124 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
8125 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
8126 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
8128 push_init_level (1, braced_init_obstack
);
8134 push_member_name (constructor_fields
);
8135 output_init_element (value
.value
, value
.original_type
,
8136 strict_string
, fieldtype
,
8137 constructor_fields
, 1, implicit
,
8138 braced_init_obstack
);
8139 RESTORE_SPELLING_DEPTH (constructor_depth
);
8142 /* Do the bookkeeping for an element that was
8143 directly output as a constructor. */
8145 constructor_bit_index
= DECL_SIZE (constructor_fields
);
8146 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
8149 constructor_fields
= 0;
8151 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8153 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8154 enum tree_code eltcode
= TREE_CODE (elttype
);
8156 /* Accept a string constant to initialize a subarray. */
8157 if (value
.value
!= 0
8158 && eltcode
== ARRAY_TYPE
8159 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
8161 value
.value
= orig_value
;
8162 /* Otherwise, if we have come to a subaggregate,
8163 and we don't have an element of its type, push into it. */
8164 else if (value
.value
!= 0
8165 && value
.value
!= error_mark_node
8166 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
8167 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
8168 || eltcode
== UNION_TYPE
|| eltcode
== VECTOR_TYPE
))
8170 push_init_level (1, braced_init_obstack
);
8174 if (constructor_max_index
!= 0
8175 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
8176 || integer_all_onesp (constructor_max_index
)))
8178 pedwarn_init (input_location
, 0,
8179 "excess elements in array initializer");
8183 /* Now output the actual element. */
8186 push_array_bounds (tree_low_cst (constructor_index
, 1));
8187 output_init_element (value
.value
, value
.original_type
,
8188 strict_string
, elttype
,
8189 constructor_index
, 1, implicit
,
8190 braced_init_obstack
);
8191 RESTORE_SPELLING_DEPTH (constructor_depth
);
8195 = size_binop_loc (input_location
, PLUS_EXPR
,
8196 constructor_index
, bitsize_one_node
);
8199 /* If we are doing the bookkeeping for an element that was
8200 directly output as a constructor, we must update
8201 constructor_unfilled_index. */
8202 constructor_unfilled_index
= constructor_index
;
8204 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
8206 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8208 /* Do a basic check of initializer size. Note that vectors
8209 always have a fixed size derived from their type. */
8210 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
8212 pedwarn_init (input_location
, 0,
8213 "excess elements in vector initializer");
8217 /* Now output the actual element. */
8220 if (TREE_CODE (value
.value
) == VECTOR_CST
)
8221 elttype
= TYPE_MAIN_VARIANT (constructor_type
);
8222 output_init_element (value
.value
, value
.original_type
,
8223 strict_string
, elttype
,
8224 constructor_index
, 1, implicit
,
8225 braced_init_obstack
);
8229 = size_binop_loc (input_location
,
8230 PLUS_EXPR
, constructor_index
, bitsize_one_node
);
8233 /* If we are doing the bookkeeping for an element that was
8234 directly output as a constructor, we must update
8235 constructor_unfilled_index. */
8236 constructor_unfilled_index
= constructor_index
;
8239 /* Handle the sole element allowed in a braced initializer
8240 for a scalar variable. */
8241 else if (constructor_type
!= error_mark_node
8242 && constructor_fields
== 0)
8244 pedwarn_init (input_location
, 0,
8245 "excess elements in scalar initializer");
8251 output_init_element (value
.value
, value
.original_type
,
8252 strict_string
, constructor_type
,
8253 NULL_TREE
, 1, implicit
,
8254 braced_init_obstack
);
8255 constructor_fields
= 0;
8258 /* Handle range initializers either at this level or anywhere higher
8259 in the designator stack. */
8260 if (constructor_range_stack
)
8262 struct constructor_range_stack
*p
, *range_stack
;
8265 range_stack
= constructor_range_stack
;
8266 constructor_range_stack
= 0;
8267 while (constructor_stack
!= range_stack
->stack
)
8269 gcc_assert (constructor_stack
->implicit
);
8270 process_init_element (pop_init_level (1,
8271 braced_init_obstack
),
8272 true, braced_init_obstack
);
8274 for (p
= range_stack
;
8275 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
8278 gcc_assert (constructor_stack
->implicit
);
8279 process_init_element (pop_init_level (1, braced_init_obstack
),
8280 true, braced_init_obstack
);
8283 p
->index
= size_binop_loc (input_location
,
8284 PLUS_EXPR
, p
->index
, bitsize_one_node
);
8285 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
8290 constructor_index
= p
->index
;
8291 constructor_fields
= p
->fields
;
8292 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
8300 push_init_level (2, braced_init_obstack
);
8301 p
->stack
= constructor_stack
;
8302 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
8303 p
->index
= p
->range_start
;
8307 constructor_range_stack
= range_stack
;
8314 constructor_range_stack
= 0;
8317 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
8318 (guaranteed to be 'volatile' or null) and ARGS (represented using
8319 an ASM_EXPR node). */
8321 build_asm_stmt (tree cv_qualifier
, tree args
)
8323 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
8324 ASM_VOLATILE_P (args
) = 1;
8325 return add_stmt (args
);
8328 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
8329 some INPUTS, and some CLOBBERS. The latter three may be NULL.
8330 SIMPLE indicates whether there was anything at all after the
8331 string in the asm expression -- asm("blah") and asm("blah" : )
8332 are subtly different. We use a ASM_EXPR node to represent this. */
8334 build_asm_expr (location_t loc
, tree string
, tree outputs
, tree inputs
,
8335 tree clobbers
, tree labels
, bool simple
)
8340 const char *constraint
;
8341 const char **oconstraints
;
8342 bool allows_mem
, allows_reg
, is_inout
;
8343 int ninputs
, noutputs
;
8345 ninputs
= list_length (inputs
);
8346 noutputs
= list_length (outputs
);
8347 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
8349 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
8351 /* Remove output conversions that change the type but not the mode. */
8352 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
8354 tree output
= TREE_VALUE (tail
);
8356 /* ??? Really, this should not be here. Users should be using a
8357 proper lvalue, dammit. But there's a long history of using casts
8358 in the output operands. In cases like longlong.h, this becomes a
8359 primitive form of typechecking -- if the cast can be removed, then
8360 the output operand had a type of the proper width; otherwise we'll
8361 get an error. Gross, but ... */
8362 STRIP_NOPS (output
);
8364 if (!lvalue_or_else (output
, lv_asm
))
8365 output
= error_mark_node
;
8367 if (output
!= error_mark_node
8368 && (TREE_READONLY (output
)
8369 || TYPE_READONLY (TREE_TYPE (output
))
8370 || ((TREE_CODE (TREE_TYPE (output
)) == RECORD_TYPE
8371 || TREE_CODE (TREE_TYPE (output
)) == UNION_TYPE
)
8372 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output
)))))
8373 readonly_error (output
, lv_asm
);
8375 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
8376 oconstraints
[i
] = constraint
;
8378 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
8379 &allows_mem
, &allows_reg
, &is_inout
))
8381 /* If the operand is going to end up in memory,
8382 mark it addressable. */
8383 if (!allows_reg
&& !c_mark_addressable (output
))
8384 output
= error_mark_node
;
8387 output
= error_mark_node
;
8389 TREE_VALUE (tail
) = output
;
8392 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
8396 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
8397 input
= TREE_VALUE (tail
);
8399 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
8400 oconstraints
, &allows_mem
, &allows_reg
))
8402 /* If the operand is going to end up in memory,
8403 mark it addressable. */
8404 if (!allows_reg
&& allows_mem
)
8406 /* Strip the nops as we allow this case. FIXME, this really
8407 should be rejected or made deprecated. */
8409 if (!c_mark_addressable (input
))
8410 input
= error_mark_node
;
8414 input
= error_mark_node
;
8416 TREE_VALUE (tail
) = input
;
8419 /* ASMs with labels cannot have outputs. This should have been
8420 enforced by the parser. */
8421 gcc_assert (outputs
== NULL
|| labels
== NULL
);
8423 args
= build_stmt (loc
, ASM_EXPR
, string
, outputs
, inputs
, clobbers
, labels
);
8425 /* asm statements without outputs, including simple ones, are treated
8427 ASM_INPUT_P (args
) = simple
;
8428 ASM_VOLATILE_P (args
) = (noutputs
== 0);
8433 /* Generate a goto statement to LABEL. LOC is the location of the
8437 c_finish_goto_label (location_t loc
, tree label
)
8439 tree decl
= lookup_label_for_goto (loc
, label
);
8442 TREE_USED (decl
) = 1;
8444 tree t
= build1 (GOTO_EXPR
, void_type_node
, decl
);
8445 SET_EXPR_LOCATION (t
, loc
);
8446 return add_stmt (t
);
8450 /* Generate a computed goto statement to EXPR. LOC is the location of
8454 c_finish_goto_ptr (location_t loc
, tree expr
)
8457 pedwarn (loc
, OPT_pedantic
, "ISO C forbids %<goto *expr;%>");
8458 expr
= c_fully_fold (expr
, false, NULL
);
8459 expr
= convert (ptr_type_node
, expr
);
8460 t
= build1 (GOTO_EXPR
, void_type_node
, expr
);
8461 SET_EXPR_LOCATION (t
, loc
);
8462 return add_stmt (t
);
8465 /* Generate a C `return' statement. RETVAL is the expression for what
8466 to return, or a null pointer for `return;' with no value. LOC is
8467 the location of the return statement. If ORIGTYPE is not NULL_TREE, it
8468 is the original type of RETVAL. */
8471 c_finish_return (location_t loc
, tree retval
, tree origtype
)
8473 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
)), ret_stmt
;
8474 bool no_warning
= false;
8477 if (TREE_THIS_VOLATILE (current_function_decl
))
8479 "function declared %<noreturn%> has a %<return%> statement");
8483 tree semantic_type
= NULL_TREE
;
8484 npc
= null_pointer_constant_p (retval
);
8485 if (TREE_CODE (retval
) == EXCESS_PRECISION_EXPR
)
8487 semantic_type
= TREE_TYPE (retval
);
8488 retval
= TREE_OPERAND (retval
, 0);
8490 retval
= c_fully_fold (retval
, false, NULL
);
8492 retval
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, retval
);
8497 current_function_returns_null
= 1;
8498 if ((warn_return_type
|| flag_isoc99
)
8499 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
8501 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wreturn_type
,
8502 "%<return%> with no value, in "
8503 "function returning non-void");
8507 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
8509 current_function_returns_null
= 1;
8510 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
8512 "%<return%> with a value, in function returning void");
8514 pedwarn (loc
, OPT_pedantic
, "ISO C forbids "
8515 "%<return%> with expression, in function returning void");
8519 tree t
= convert_for_assignment (loc
, valtype
, retval
, origtype
,
8521 npc
, NULL_TREE
, NULL_TREE
, 0);
8522 tree res
= DECL_RESULT (current_function_decl
);
8525 current_function_returns_value
= 1;
8526 if (t
== error_mark_node
)
8529 inner
= t
= convert (TREE_TYPE (res
), t
);
8531 /* Strip any conversions, additions, and subtractions, and see if
8532 we are returning the address of a local variable. Warn if so. */
8535 switch (TREE_CODE (inner
))
8538 case NON_LVALUE_EXPR
:
8540 case POINTER_PLUS_EXPR
:
8541 inner
= TREE_OPERAND (inner
, 0);
8545 /* If the second operand of the MINUS_EXPR has a pointer
8546 type (or is converted from it), this may be valid, so
8547 don't give a warning. */
8549 tree op1
= TREE_OPERAND (inner
, 1);
8551 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
8552 && (CONVERT_EXPR_P (op1
)
8553 || TREE_CODE (op1
) == NON_LVALUE_EXPR
))
8554 op1
= TREE_OPERAND (op1
, 0);
8556 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
8559 inner
= TREE_OPERAND (inner
, 0);
8564 inner
= TREE_OPERAND (inner
, 0);
8566 while (REFERENCE_CLASS_P (inner
)
8567 && TREE_CODE (inner
) != INDIRECT_REF
)
8568 inner
= TREE_OPERAND (inner
, 0);
8571 && !DECL_EXTERNAL (inner
)
8572 && !TREE_STATIC (inner
)
8573 && DECL_CONTEXT (inner
) == current_function_decl
)
8575 0, "function returns address of local variable");
8585 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
8586 SET_EXPR_LOCATION (retval
, loc
);
8588 if (warn_sequence_point
)
8589 verify_sequence_points (retval
);
8592 ret_stmt
= build_stmt (loc
, RETURN_EXPR
, retval
);
8593 TREE_NO_WARNING (ret_stmt
) |= no_warning
;
8594 return add_stmt (ret_stmt
);
8598 /* The SWITCH_EXPR being built. */
8601 /* The original type of the testing expression, i.e. before the
8602 default conversion is applied. */
8605 /* A splay-tree mapping the low element of a case range to the high
8606 element, or NULL_TREE if there is no high element. Used to
8607 determine whether or not a new case label duplicates an old case
8608 label. We need a tree, rather than simply a hash table, because
8609 of the GNU case range extension. */
8612 /* The bindings at the point of the switch. This is used for
8613 warnings crossing decls when branching to a case label. */
8614 struct c_spot_bindings
*bindings
;
8616 /* The next node on the stack. */
8617 struct c_switch
*next
;
8620 /* A stack of the currently active switch statements. The innermost
8621 switch statement is on the top of the stack. There is no need to
8622 mark the stack for garbage collection because it is only active
8623 during the processing of the body of a function, and we never
8624 collect at that point. */
8626 struct c_switch
*c_switch_stack
;
8628 /* Start a C switch statement, testing expression EXP. Return the new
8629 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
8630 SWITCH_COND_LOC is the location of the switch's condition. */
8633 c_start_case (location_t switch_loc
,
8634 location_t switch_cond_loc
,
8637 tree orig_type
= error_mark_node
;
8638 struct c_switch
*cs
;
8640 if (exp
!= error_mark_node
)
8642 orig_type
= TREE_TYPE (exp
);
8644 if (!INTEGRAL_TYPE_P (orig_type
))
8646 if (orig_type
!= error_mark_node
)
8648 error_at (switch_cond_loc
, "switch quantity not an integer");
8649 orig_type
= error_mark_node
;
8651 exp
= integer_zero_node
;
8655 tree type
= TYPE_MAIN_VARIANT (orig_type
);
8657 if (!in_system_header
8658 && (type
== long_integer_type_node
8659 || type
== long_unsigned_type_node
))
8660 warning_at (switch_cond_loc
,
8661 OPT_Wtraditional
, "%<long%> switch expression not "
8662 "converted to %<int%> in ISO C");
8664 exp
= c_fully_fold (exp
, false, NULL
);
8665 exp
= default_conversion (exp
);
8667 if (warn_sequence_point
)
8668 verify_sequence_points (exp
);
8672 /* Add this new SWITCH_EXPR to the stack. */
8673 cs
= XNEW (struct c_switch
);
8674 cs
->switch_expr
= build3 (SWITCH_EXPR
, orig_type
, exp
, NULL_TREE
, NULL_TREE
);
8675 SET_EXPR_LOCATION (cs
->switch_expr
, switch_loc
);
8676 cs
->orig_type
= orig_type
;
8677 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
8678 cs
->bindings
= c_get_switch_bindings ();
8679 cs
->next
= c_switch_stack
;
8680 c_switch_stack
= cs
;
8682 return add_stmt (cs
->switch_expr
);
8685 /* Process a case label at location LOC. */
8688 do_case (location_t loc
, tree low_value
, tree high_value
)
8690 tree label
= NULL_TREE
;
8692 if (low_value
&& TREE_CODE (low_value
) != INTEGER_CST
)
8694 low_value
= c_fully_fold (low_value
, false, NULL
);
8695 if (TREE_CODE (low_value
) == INTEGER_CST
)
8696 pedwarn (input_location
, OPT_pedantic
,
8697 "case label is not an integer constant expression");
8700 if (high_value
&& TREE_CODE (high_value
) != INTEGER_CST
)
8702 high_value
= c_fully_fold (high_value
, false, NULL
);
8703 if (TREE_CODE (high_value
) == INTEGER_CST
)
8704 pedwarn (input_location
, OPT_pedantic
,
8705 "case label is not an integer constant expression");
8708 if (c_switch_stack
== NULL
)
8711 error_at (loc
, "case label not within a switch statement");
8713 error_at (loc
, "%<default%> label not within a switch statement");
8717 if (c_check_switch_jump_warnings (c_switch_stack
->bindings
,
8718 EXPR_LOCATION (c_switch_stack
->switch_expr
),
8722 label
= c_add_case_label (loc
, c_switch_stack
->cases
,
8723 SWITCH_COND (c_switch_stack
->switch_expr
),
8724 c_switch_stack
->orig_type
,
8725 low_value
, high_value
);
8726 if (label
== error_mark_node
)
8731 /* Finish the switch statement. */
8734 c_finish_case (tree body
)
8736 struct c_switch
*cs
= c_switch_stack
;
8737 location_t switch_location
;
8739 SWITCH_BODY (cs
->switch_expr
) = body
;
8741 /* Emit warnings as needed. */
8742 switch_location
= EXPR_LOCATION (cs
->switch_expr
);
8743 c_do_switch_warnings (cs
->cases
, switch_location
,
8744 TREE_TYPE (cs
->switch_expr
),
8745 SWITCH_COND (cs
->switch_expr
));
8747 /* Pop the stack. */
8748 c_switch_stack
= cs
->next
;
8749 splay_tree_delete (cs
->cases
);
8750 c_release_switch_bindings (cs
->bindings
);
8754 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
8755 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8756 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
8757 statement, and was not surrounded with parenthesis. */
8760 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
8761 tree else_block
, bool nested_if
)
8765 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
8766 if (warn_parentheses
&& nested_if
&& else_block
== NULL
)
8768 tree inner_if
= then_block
;
8770 /* We know from the grammar productions that there is an IF nested
8771 within THEN_BLOCK. Due to labels and c99 conditional declarations,
8772 it might not be exactly THEN_BLOCK, but should be the last
8773 non-container statement within. */
8775 switch (TREE_CODE (inner_if
))
8780 inner_if
= BIND_EXPR_BODY (inner_if
);
8782 case STATEMENT_LIST
:
8783 inner_if
= expr_last (then_block
);
8785 case TRY_FINALLY_EXPR
:
8786 case TRY_CATCH_EXPR
:
8787 inner_if
= TREE_OPERAND (inner_if
, 0);
8794 if (COND_EXPR_ELSE (inner_if
))
8795 warning_at (if_locus
, OPT_Wparentheses
,
8796 "suggest explicit braces to avoid ambiguous %<else%>");
8799 stmt
= build3 (COND_EXPR
, void_type_node
, cond
, then_block
, else_block
);
8800 SET_EXPR_LOCATION (stmt
, if_locus
);
8804 /* Emit a general-purpose loop construct. START_LOCUS is the location of
8805 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
8806 is false for DO loops. INCR is the FOR increment expression. BODY is
8807 the statement controlled by the loop. BLAB is the break label. CLAB is
8808 the continue label. Everything is allowed to be NULL. */
8811 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
8812 tree blab
, tree clab
, bool cond_is_first
)
8814 tree entry
= NULL
, exit
= NULL
, t
;
8816 /* If the condition is zero don't generate a loop construct. */
8817 if (cond
&& integer_zerop (cond
))
8821 t
= build_and_jump (&blab
);
8822 SET_EXPR_LOCATION (t
, start_locus
);
8828 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
8830 /* If we have an exit condition, then we build an IF with gotos either
8831 out of the loop, or to the top of it. If there's no exit condition,
8832 then we just build a jump back to the top. */
8833 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
8835 if (cond
&& !integer_nonzerop (cond
))
8837 /* Canonicalize the loop condition to the end. This means
8838 generating a branch to the loop condition. Reuse the
8839 continue label, if possible. */
8844 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
8845 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
8848 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
8849 SET_EXPR_LOCATION (t
, start_locus
);
8853 t
= build_and_jump (&blab
);
8855 exit
= fold_build3_loc (start_locus
,
8856 COND_EXPR
, void_type_node
, cond
, exit
, t
);
8858 exit
= fold_build3_loc (input_location
,
8859 COND_EXPR
, void_type_node
, cond
, exit
, t
);
8868 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
8876 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
8880 c_finish_bc_stmt (location_t loc
, tree
*label_p
, bool is_break
)
8883 tree label
= *label_p
;
8885 /* In switch statements break is sometimes stylistically used after
8886 a return statement. This can lead to spurious warnings about
8887 control reaching the end of a non-void function when it is
8888 inlined. Note that we are calling block_may_fallthru with
8889 language specific tree nodes; this works because
8890 block_may_fallthru returns true when given something it does not
8892 skip
= !block_may_fallthru (cur_stmt_list
);
8897 *label_p
= label
= create_artificial_label (loc
);
8899 else if (TREE_CODE (label
) == LABEL_DECL
)
8901 else switch (TREE_INT_CST_LOW (label
))
8905 error_at (loc
, "break statement not within loop or switch");
8907 error_at (loc
, "continue statement not within a loop");
8911 gcc_assert (is_break
);
8912 error_at (loc
, "break statement used with OpenMP for loop");
8923 add_stmt (build_predict_expr (PRED_CONTINUE
, NOT_TAKEN
));
8925 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
8928 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
8931 emit_side_effect_warnings (location_t loc
, tree expr
)
8933 if (expr
== error_mark_node
)
8935 else if (!TREE_SIDE_EFFECTS (expr
))
8937 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
8938 warning_at (loc
, OPT_Wunused_value
, "statement with no effect");
8941 warn_if_unused_value (expr
, loc
);
8944 /* Process an expression as if it were a complete statement. Emit
8945 diagnostics, but do not call ADD_STMT. LOC is the location of the
8949 c_process_expr_stmt (location_t loc
, tree expr
)
8956 expr
= c_fully_fold (expr
, false, NULL
);
8958 if (warn_sequence_point
)
8959 verify_sequence_points (expr
);
8961 if (TREE_TYPE (expr
) != error_mark_node
8962 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
8963 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
8964 error_at (loc
, "expression statement has incomplete type");
8966 /* If we're not processing a statement expression, warn about unused values.
8967 Warnings for statement expressions will be emitted later, once we figure
8968 out which is the result. */
8969 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
8970 && warn_unused_value
)
8971 emit_side_effect_warnings (loc
, expr
);
8974 while (TREE_CODE (exprv
) == COMPOUND_EXPR
)
8975 exprv
= TREE_OPERAND (exprv
, 1);
8976 if (DECL_P (exprv
) || handled_component_p (exprv
))
8977 mark_exp_read (exprv
);
8979 /* If the expression is not of a type to which we cannot assign a line
8980 number, wrap the thing in a no-op NOP_EXPR. */
8981 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
8983 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
8984 SET_EXPR_LOCATION (expr
, loc
);
8990 /* Emit an expression as a statement. LOC is the location of the
8994 c_finish_expr_stmt (location_t loc
, tree expr
)
8997 return add_stmt (c_process_expr_stmt (loc
, expr
));
9002 /* Do the opposite and emit a statement as an expression. To begin,
9003 create a new binding level and return it. */
9006 c_begin_stmt_expr (void)
9010 /* We must force a BLOCK for this level so that, if it is not expanded
9011 later, there is a way to turn off the entire subtree of blocks that
9012 are contained in it. */
9014 ret
= c_begin_compound_stmt (true);
9016 c_bindings_start_stmt_expr (c_switch_stack
== NULL
9018 : c_switch_stack
->bindings
);
9020 /* Mark the current statement list as belonging to a statement list. */
9021 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
9026 /* LOC is the location of the compound statement to which this body
9030 c_finish_stmt_expr (location_t loc
, tree body
)
9032 tree last
, type
, tmp
, val
;
9035 body
= c_end_compound_stmt (loc
, body
, true);
9037 c_bindings_end_stmt_expr (c_switch_stack
== NULL
9039 : c_switch_stack
->bindings
);
9041 /* Locate the last statement in BODY. See c_end_compound_stmt
9042 about always returning a BIND_EXPR. */
9043 last_p
= &BIND_EXPR_BODY (body
);
9044 last
= BIND_EXPR_BODY (body
);
9047 if (TREE_CODE (last
) == STATEMENT_LIST
)
9049 tree_stmt_iterator i
;
9051 /* This can happen with degenerate cases like ({ }). No value. */
9052 if (!TREE_SIDE_EFFECTS (last
))
9055 /* If we're supposed to generate side effects warnings, process
9056 all of the statements except the last. */
9057 if (warn_unused_value
)
9059 for (i
= tsi_start (last
); !tsi_one_before_end_p (i
); tsi_next (&i
))
9062 tree t
= tsi_stmt (i
);
9064 tloc
= EXPR_HAS_LOCATION (t
) ? EXPR_LOCATION (t
) : loc
;
9065 emit_side_effect_warnings (tloc
, t
);
9069 i
= tsi_last (last
);
9070 last_p
= tsi_stmt_ptr (i
);
9074 /* If the end of the list is exception related, then the list was split
9075 by a call to push_cleanup. Continue searching. */
9076 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
9077 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
9079 last_p
= &TREE_OPERAND (last
, 0);
9081 goto continue_searching
;
9084 if (last
== error_mark_node
)
9087 /* In the case that the BIND_EXPR is not necessary, return the
9088 expression out from inside it. */
9089 if (last
== BIND_EXPR_BODY (body
)
9090 && BIND_EXPR_VARS (body
) == NULL
)
9092 /* Even if this looks constant, do not allow it in a constant
9094 last
= c_wrap_maybe_const (last
, true);
9095 /* Do not warn if the return value of a statement expression is
9097 TREE_NO_WARNING (last
) = 1;
9101 /* Extract the type of said expression. */
9102 type
= TREE_TYPE (last
);
9104 /* If we're not returning a value at all, then the BIND_EXPR that
9105 we already have is a fine expression to return. */
9106 if (!type
|| VOID_TYPE_P (type
))
9109 /* Now that we've located the expression containing the value, it seems
9110 silly to make voidify_wrapper_expr repeat the process. Create a
9111 temporary of the appropriate type and stick it in a TARGET_EXPR. */
9112 tmp
= create_tmp_var_raw (type
, NULL
);
9114 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
9115 tree_expr_nonnegative_p giving up immediately. */
9117 if (TREE_CODE (val
) == NOP_EXPR
9118 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
9119 val
= TREE_OPERAND (val
, 0);
9121 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
9122 SET_EXPR_LOCATION (*last_p
, EXPR_LOCATION (last
));
9125 tree t
= build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
9126 SET_EXPR_LOCATION (t
, loc
);
9131 /* Begin and end compound statements. This is as simple as pushing
9132 and popping new statement lists from the tree. */
9135 c_begin_compound_stmt (bool do_scope
)
9137 tree stmt
= push_stmt_list ();
9143 /* End a compound statement. STMT is the statement. LOC is the
9144 location of the compound statement-- this is usually the location
9145 of the opening brace. */
9148 c_end_compound_stmt (location_t loc
, tree stmt
, bool do_scope
)
9154 if (c_dialect_objc ())
9155 objc_clear_super_receiver ();
9156 block
= pop_scope ();
9159 stmt
= pop_stmt_list (stmt
);
9160 stmt
= c_build_bind_expr (loc
, block
, stmt
);
9162 /* If this compound statement is nested immediately inside a statement
9163 expression, then force a BIND_EXPR to be created. Otherwise we'll
9164 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
9165 STATEMENT_LISTs merge, and thus we can lose track of what statement
9168 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
9169 && TREE_CODE (stmt
) != BIND_EXPR
)
9171 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
9172 TREE_SIDE_EFFECTS (stmt
) = 1;
9173 SET_EXPR_LOCATION (stmt
, loc
);
9179 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
9180 when the current scope is exited. EH_ONLY is true when this is not
9181 meant to apply to normal control flow transfer. */
9184 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
9186 enum tree_code code
;
9190 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
9191 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), code
, NULL
, cleanup
);
9193 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
9194 list
= push_stmt_list ();
9195 TREE_OPERAND (stmt
, 0) = list
;
9196 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
9199 /* Build a binary-operation expression without default conversions.
9200 CODE is the kind of expression to build.
9201 LOCATION is the operator's location.
9202 This function differs from `build' in several ways:
9203 the data type of the result is computed and recorded in it,
9204 warnings are generated if arg data types are invalid,
9205 special handling for addition and subtraction of pointers is known,
9206 and some optimization is done (operations on narrow ints
9207 are done in the narrower type when that gives the same result).
9208 Constant folding is also done before the result is returned.
9210 Note that the operands will never have enumeral types, or function
9211 or array types, because either they will have the default conversions
9212 performed or they have both just been converted to some other type in which
9213 the arithmetic is to be done. */
9216 build_binary_op (location_t location
, enum tree_code code
,
9217 tree orig_op0
, tree orig_op1
, int convert_p
)
9219 tree type0
, type1
, orig_type0
, orig_type1
;
9221 enum tree_code code0
, code1
;
9223 tree ret
= error_mark_node
;
9224 const char *invalid_op_diag
;
9225 bool op0_int_operands
, op1_int_operands
;
9226 bool int_const
, int_const_or_overflow
, int_operands
;
9228 /* Expression code to give to the expression when it is built.
9229 Normally this is CODE, which is what the caller asked for,
9230 but in some special cases we change it. */
9231 enum tree_code resultcode
= code
;
9233 /* Data type in which the computation is to be performed.
9234 In the simplest cases this is the common type of the arguments. */
9235 tree result_type
= NULL
;
9237 /* When the computation is in excess precision, the type of the
9238 final EXCESS_PRECISION_EXPR. */
9239 tree semantic_result_type
= NULL
;
9241 /* Nonzero means operands have already been type-converted
9242 in whatever way is necessary.
9243 Zero means they need to be converted to RESULT_TYPE. */
9246 /* Nonzero means create the expression with this type, rather than
9248 tree build_type
= 0;
9250 /* Nonzero means after finally constructing the expression
9251 convert it to this type. */
9252 tree final_type
= 0;
9254 /* Nonzero if this is an operation like MIN or MAX which can
9255 safely be computed in short if both args are promoted shorts.
9256 Also implies COMMON.
9257 -1 indicates a bitwise operation; this makes a difference
9258 in the exact conditions for when it is safe to do the operation
9259 in a narrower mode. */
9262 /* Nonzero if this is a comparison operation;
9263 if both args are promoted shorts, compare the original shorts.
9264 Also implies COMMON. */
9265 int short_compare
= 0;
9267 /* Nonzero if this is a right-shift operation, which can be computed on the
9268 original short and then promoted if the operand is a promoted short. */
9269 int short_shift
= 0;
9271 /* Nonzero means set RESULT_TYPE to the common type of the args. */
9274 /* True means types are compatible as far as ObjC is concerned. */
9277 /* True means this is an arithmetic operation that may need excess
9279 bool may_need_excess_precision
;
9281 if (location
== UNKNOWN_LOCATION
)
9282 location
= input_location
;
9287 op0_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op0
);
9288 if (op0_int_operands
)
9289 op0
= remove_c_maybe_const_expr (op0
);
9290 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
9291 if (op1_int_operands
)
9292 op1
= remove_c_maybe_const_expr (op1
);
9293 int_operands
= (op0_int_operands
&& op1_int_operands
);
9296 int_const_or_overflow
= (TREE_CODE (orig_op0
) == INTEGER_CST
9297 && TREE_CODE (orig_op1
) == INTEGER_CST
);
9298 int_const
= (int_const_or_overflow
9299 && !TREE_OVERFLOW (orig_op0
)
9300 && !TREE_OVERFLOW (orig_op1
));
9303 int_const
= int_const_or_overflow
= false;
9307 op0
= default_conversion (op0
);
9308 op1
= default_conversion (op1
);
9311 orig_type0
= type0
= TREE_TYPE (op0
);
9312 orig_type1
= type1
= TREE_TYPE (op1
);
9314 /* The expression codes of the data types of the arguments tell us
9315 whether the arguments are integers, floating, pointers, etc. */
9316 code0
= TREE_CODE (type0
);
9317 code1
= TREE_CODE (type1
);
9319 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
9320 STRIP_TYPE_NOPS (op0
);
9321 STRIP_TYPE_NOPS (op1
);
9323 /* If an error was already reported for one of the arguments,
9324 avoid reporting another error. */
9326 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
9327 return error_mark_node
;
9329 if ((invalid_op_diag
9330 = targetm
.invalid_binary_op (code
, type0
, type1
)))
9332 error_at (location
, invalid_op_diag
);
9333 return error_mark_node
;
9341 case TRUNC_DIV_EXPR
:
9343 case FLOOR_DIV_EXPR
:
9344 case ROUND_DIV_EXPR
:
9345 case EXACT_DIV_EXPR
:
9346 may_need_excess_precision
= true;
9349 may_need_excess_precision
= false;
9352 if (TREE_CODE (op0
) == EXCESS_PRECISION_EXPR
)
9354 op0
= TREE_OPERAND (op0
, 0);
9355 type0
= TREE_TYPE (op0
);
9357 else if (may_need_excess_precision
9358 && (eptype
= excess_precision_type (type0
)) != NULL_TREE
)
9361 op0
= convert (eptype
, op0
);
9363 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
9365 op1
= TREE_OPERAND (op1
, 0);
9366 type1
= TREE_TYPE (op1
);
9368 else if (may_need_excess_precision
9369 && (eptype
= excess_precision_type (type1
)) != NULL_TREE
)
9372 op1
= convert (eptype
, op1
);
9375 objc_ok
= objc_compare_types (type0
, type1
, -3, NULL_TREE
);
9380 /* Handle the pointer + int case. */
9381 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9383 ret
= pointer_int_sum (location
, PLUS_EXPR
, op0
, op1
);
9384 goto return_build_binary_op
;
9386 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
9388 ret
= pointer_int_sum (location
, PLUS_EXPR
, op1
, op0
);
9389 goto return_build_binary_op
;
9396 /* Subtraction of two similar pointers.
9397 We must subtract them as integers, then divide by object size. */
9398 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
9399 && comp_target_types (location
, type0
, type1
))
9401 ret
= pointer_diff (location
, op0
, op1
);
9402 goto return_build_binary_op
;
9404 /* Handle pointer minus int. Just like pointer plus int. */
9405 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9407 ret
= pointer_int_sum (location
, MINUS_EXPR
, op0
, op1
);
9408 goto return_build_binary_op
;
9418 case TRUNC_DIV_EXPR
:
9420 case FLOOR_DIV_EXPR
:
9421 case ROUND_DIV_EXPR
:
9422 case EXACT_DIV_EXPR
:
9423 warn_for_div_by_zero (location
, op1
);
9425 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
9426 || code0
== FIXED_POINT_TYPE
9427 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
9428 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
9429 || code1
== FIXED_POINT_TYPE
9430 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
9432 enum tree_code tcode0
= code0
, tcode1
= code1
;
9434 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
9435 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
9436 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
9437 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
9439 if (!((tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
)
9440 || (tcode0
== FIXED_POINT_TYPE
&& tcode1
== FIXED_POINT_TYPE
)))
9441 resultcode
= RDIV_EXPR
;
9443 /* Although it would be tempting to shorten always here, that
9444 loses on some targets, since the modulo instruction is
9445 undefined if the quotient can't be represented in the
9446 computation mode. We shorten only if unsigned or if
9447 dividing by something we know != -1. */
9448 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
9449 || (TREE_CODE (op1
) == INTEGER_CST
9450 && !integer_all_onesp (op1
)));
9458 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
9460 /* Allow vector types which are not floating point types. */
9461 else if (code0
== VECTOR_TYPE
9462 && code1
== VECTOR_TYPE
9463 && !VECTOR_FLOAT_TYPE_P (type0
)
9464 && !VECTOR_FLOAT_TYPE_P (type1
))
9468 case TRUNC_MOD_EXPR
:
9469 case FLOOR_MOD_EXPR
:
9470 warn_for_div_by_zero (location
, op1
);
9472 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
9473 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
9474 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
9476 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
9478 /* Although it would be tempting to shorten always here, that loses
9479 on some targets, since the modulo instruction is undefined if the
9480 quotient can't be represented in the computation mode. We shorten
9481 only if unsigned or if dividing by something we know != -1. */
9482 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
9483 || (TREE_CODE (op1
) == INTEGER_CST
9484 && !integer_all_onesp (op1
)));
9489 case TRUTH_ANDIF_EXPR
:
9490 case TRUTH_ORIF_EXPR
:
9491 case TRUTH_AND_EXPR
:
9493 case TRUTH_XOR_EXPR
:
9494 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
9495 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
9496 || code0
== FIXED_POINT_TYPE
)
9497 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
9498 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
9499 || code1
== FIXED_POINT_TYPE
))
9501 /* Result of these operations is always an int,
9502 but that does not mean the operands should be
9503 converted to ints! */
9504 result_type
= integer_type_node
;
9505 op0
= c_common_truthvalue_conversion (location
, op0
);
9506 op1
= c_common_truthvalue_conversion (location
, op1
);
9509 if (code
== TRUTH_ANDIF_EXPR
)
9511 int_const_or_overflow
= (int_operands
9512 && TREE_CODE (orig_op0
) == INTEGER_CST
9513 && (op0
== truthvalue_false_node
9514 || TREE_CODE (orig_op1
) == INTEGER_CST
));
9515 int_const
= (int_const_or_overflow
9516 && !TREE_OVERFLOW (orig_op0
)
9517 && (op0
== truthvalue_false_node
9518 || !TREE_OVERFLOW (orig_op1
)));
9520 else if (code
== TRUTH_ORIF_EXPR
)
9522 int_const_or_overflow
= (int_operands
9523 && TREE_CODE (orig_op0
) == INTEGER_CST
9524 && (op0
== truthvalue_true_node
9525 || TREE_CODE (orig_op1
) == INTEGER_CST
));
9526 int_const
= (int_const_or_overflow
9527 && !TREE_OVERFLOW (orig_op0
)
9528 && (op0
== truthvalue_true_node
9529 || !TREE_OVERFLOW (orig_op1
)));
9533 /* Shift operations: result has same type as first operand;
9534 always convert second operand to int.
9535 Also set SHORT_SHIFT if shifting rightward. */
9538 if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
)
9539 && code1
== INTEGER_TYPE
)
9541 if (TREE_CODE (op1
) == INTEGER_CST
)
9543 if (tree_int_cst_sgn (op1
) < 0)
9546 if (c_inhibit_evaluation_warnings
== 0)
9547 warning (0, "right shift count is negative");
9551 if (!integer_zerop (op1
))
9554 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
9557 if (c_inhibit_evaluation_warnings
== 0)
9558 warning (0, "right shift count >= width of type");
9563 /* Use the type of the value to be shifted. */
9564 result_type
= type0
;
9565 /* Convert the shift-count to an integer, regardless of size
9566 of value being shifted. */
9567 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
9568 op1
= convert (integer_type_node
, op1
);
9569 /* Avoid converting op1 to result_type later. */
9575 if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
)
9576 && code1
== INTEGER_TYPE
)
9578 if (TREE_CODE (op1
) == INTEGER_CST
)
9580 if (tree_int_cst_sgn (op1
) < 0)
9583 if (c_inhibit_evaluation_warnings
== 0)
9584 warning (0, "left shift count is negative");
9587 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
9590 if (c_inhibit_evaluation_warnings
== 0)
9591 warning (0, "left shift count >= width of type");
9595 /* Use the type of the value to be shifted. */
9596 result_type
= type0
;
9597 /* Convert the shift-count to an integer, regardless of size
9598 of value being shifted. */
9599 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
9600 op1
= convert (integer_type_node
, op1
);
9601 /* Avoid converting op1 to result_type later. */
9608 if (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
))
9609 warning_at (location
,
9611 "comparing floating point with == or != is unsafe");
9612 /* Result of comparison is always int,
9613 but don't convert the args to int! */
9614 build_type
= integer_type_node
;
9615 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
9616 || code0
== FIXED_POINT_TYPE
|| code0
== COMPLEX_TYPE
)
9617 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
9618 || code1
== FIXED_POINT_TYPE
|| code1
== COMPLEX_TYPE
))
9620 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
9622 if (TREE_CODE (op0
) == ADDR_EXPR
9623 && decl_with_nonnull_addr_p (TREE_OPERAND (op0
, 0)))
9625 if (code
== EQ_EXPR
)
9626 warning_at (location
,
9628 "the comparison will always evaluate as %<false%> "
9629 "for the address of %qD will never be NULL",
9630 TREE_OPERAND (op0
, 0));
9632 warning_at (location
,
9634 "the comparison will always evaluate as %<true%> "
9635 "for the address of %qD will never be NULL",
9636 TREE_OPERAND (op0
, 0));
9638 result_type
= type0
;
9640 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
9642 if (TREE_CODE (op1
) == ADDR_EXPR
9643 && decl_with_nonnull_addr_p (TREE_OPERAND (op1
, 0)))
9645 if (code
== EQ_EXPR
)
9646 warning_at (location
,
9648 "the comparison will always evaluate as %<false%> "
9649 "for the address of %qD will never be NULL",
9650 TREE_OPERAND (op1
, 0));
9652 warning_at (location
,
9654 "the comparison will always evaluate as %<true%> "
9655 "for the address of %qD will never be NULL",
9656 TREE_OPERAND (op1
, 0));
9658 result_type
= type1
;
9660 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
9662 tree tt0
= TREE_TYPE (type0
);
9663 tree tt1
= TREE_TYPE (type1
);
9664 addr_space_t as0
= TYPE_ADDR_SPACE (tt0
);
9665 addr_space_t as1
= TYPE_ADDR_SPACE (tt1
);
9666 addr_space_t as_common
= ADDR_SPACE_GENERIC
;
9668 /* Anything compares with void *. void * compares with anything.
9669 Otherwise, the targets must be compatible
9670 and both must be object or both incomplete. */
9671 if (comp_target_types (location
, type0
, type1
))
9672 result_type
= common_pointer_type (type0
, type1
);
9673 else if (!addr_space_superset (as0
, as1
, &as_common
))
9675 error_at (location
, "comparison of pointers to "
9676 "disjoint address spaces");
9677 return error_mark_node
;
9679 else if (VOID_TYPE_P (tt0
))
9681 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
)
9682 pedwarn (location
, OPT_pedantic
, "ISO C forbids "
9683 "comparison of %<void *%> with function pointer");
9685 else if (VOID_TYPE_P (tt1
))
9687 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
)
9688 pedwarn (location
, OPT_pedantic
, "ISO C forbids "
9689 "comparison of %<void *%> with function pointer");
9692 /* Avoid warning about the volatile ObjC EH puts on decls. */
9694 pedwarn (location
, 0,
9695 "comparison of distinct pointer types lacks a cast");
9697 if (result_type
== NULL_TREE
)
9699 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
9700 result_type
= build_pointer_type
9701 (build_qualified_type (void_type_node
, qual
));
9704 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9706 result_type
= type0
;
9707 pedwarn (location
, 0, "comparison between pointer and integer");
9709 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
9711 result_type
= type1
;
9712 pedwarn (location
, 0, "comparison between pointer and integer");
9720 build_type
= integer_type_node
;
9721 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
9722 || code0
== FIXED_POINT_TYPE
)
9723 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
9724 || code1
== FIXED_POINT_TYPE
))
9726 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
9728 addr_space_t as0
= TYPE_ADDR_SPACE (TREE_TYPE (type0
));
9729 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
9730 addr_space_t as_common
;
9732 if (comp_target_types (location
, type0
, type1
))
9734 result_type
= common_pointer_type (type0
, type1
);
9735 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
9736 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
9737 pedwarn (location
, 0,
9738 "comparison of complete and incomplete pointers");
9739 else if (TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
9740 pedwarn (location
, OPT_pedantic
, "ISO C forbids "
9741 "ordered comparisons of pointers to functions");
9742 else if (null_pointer_constant_p (orig_op0
)
9743 || null_pointer_constant_p (orig_op1
))
9744 warning_at (location
, OPT_Wextra
,
9745 "ordered comparison of pointer with null pointer");
9748 else if (!addr_space_superset (as0
, as1
, &as_common
))
9750 error_at (location
, "comparison of pointers to "
9751 "disjoint address spaces");
9752 return error_mark_node
;
9756 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
9757 result_type
= build_pointer_type
9758 (build_qualified_type (void_type_node
, qual
));
9759 pedwarn (location
, 0,
9760 "comparison of distinct pointer types lacks a cast");
9763 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
9765 result_type
= type0
;
9767 pedwarn (location
, OPT_pedantic
,
9768 "ordered comparison of pointer with integer zero");
9769 else if (extra_warnings
)
9770 warning_at (location
, OPT_Wextra
,
9771 "ordered comparison of pointer with integer zero");
9773 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
9775 result_type
= type1
;
9777 pedwarn (location
, OPT_pedantic
,
9778 "ordered comparison of pointer with integer zero");
9779 else if (extra_warnings
)
9780 warning_at (location
, OPT_Wextra
,
9781 "ordered comparison of pointer with integer zero");
9783 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9785 result_type
= type0
;
9786 pedwarn (location
, 0, "comparison between pointer and integer");
9788 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
9790 result_type
= type1
;
9791 pedwarn (location
, 0, "comparison between pointer and integer");
9799 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
9800 return error_mark_node
;
9802 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
9803 && (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
9804 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0
),
9805 TREE_TYPE (type1
))))
9807 binary_op_error (location
, code
, type0
, type1
);
9808 return error_mark_node
;
9811 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
9812 || code0
== FIXED_POINT_TYPE
|| code0
== VECTOR_TYPE
)
9814 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
9815 || code1
== FIXED_POINT_TYPE
|| code1
== VECTOR_TYPE
))
9817 bool first_complex
= (code0
== COMPLEX_TYPE
);
9818 bool second_complex
= (code1
== COMPLEX_TYPE
);
9819 int none_complex
= (!first_complex
&& !second_complex
);
9821 if (shorten
|| common
|| short_compare
)
9823 result_type
= c_common_type (type0
, type1
);
9824 if (result_type
== error_mark_node
)
9825 return error_mark_node
;
9828 if (first_complex
!= second_complex
9829 && (code
== PLUS_EXPR
9830 || code
== MINUS_EXPR
9831 || code
== MULT_EXPR
9832 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
9833 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
9834 && flag_signed_zeros
)
9836 /* An operation on mixed real/complex operands must be
9837 handled specially, but the language-independent code can
9838 more easily optimize the plain complex arithmetic if
9839 -fno-signed-zeros. */
9840 tree real_type
= TREE_TYPE (result_type
);
9842 if (type0
!= orig_type0
|| type1
!= orig_type1
)
9844 gcc_assert (may_need_excess_precision
&& common
);
9845 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
9849 if (TREE_TYPE (op0
) != result_type
)
9850 op0
= convert_and_check (result_type
, op0
);
9851 if (TREE_TYPE (op1
) != real_type
)
9852 op1
= convert_and_check (real_type
, op1
);
9856 if (TREE_TYPE (op0
) != real_type
)
9857 op0
= convert_and_check (real_type
, op0
);
9858 if (TREE_TYPE (op1
) != result_type
)
9859 op1
= convert_and_check (result_type
, op1
);
9861 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
9862 return error_mark_node
;
9865 op0
= c_save_expr (op0
);
9866 real
= build_unary_op (EXPR_LOCATION (orig_op0
), REALPART_EXPR
,
9868 imag
= build_unary_op (EXPR_LOCATION (orig_op0
), IMAGPART_EXPR
,
9873 case TRUNC_DIV_EXPR
:
9874 imag
= build2 (resultcode
, real_type
, imag
, op1
);
9878 real
= build2 (resultcode
, real_type
, real
, op1
);
9886 op1
= c_save_expr (op1
);
9887 real
= build_unary_op (EXPR_LOCATION (orig_op1
), REALPART_EXPR
,
9889 imag
= build_unary_op (EXPR_LOCATION (orig_op1
), IMAGPART_EXPR
,
9894 imag
= build2 (resultcode
, real_type
, op0
, imag
);
9897 real
= build2 (resultcode
, real_type
, op0
, real
);
9900 real
= build2 (resultcode
, real_type
, op0
, real
);
9901 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
9907 ret
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
9908 goto return_build_binary_op
;
9911 /* For certain operations (which identify themselves by shorten != 0)
9912 if both args were extended from the same smaller type,
9913 do the arithmetic in that type and then extend.
9915 shorten !=0 and !=1 indicates a bitwise operation.
9916 For them, this optimization is safe only if
9917 both args are zero-extended or both are sign-extended.
9918 Otherwise, we might change the result.
9919 Eg, (short)-1 | (unsigned short)-1 is (int)-1
9920 but calculated in (unsigned short) it would be (unsigned short)-1. */
9922 if (shorten
&& none_complex
)
9924 final_type
= result_type
;
9925 result_type
= shorten_binary_op (result_type
, op0
, op1
,
9929 /* Shifts can be shortened if shifting right. */
9934 tree arg0
= get_narrower (op0
, &unsigned_arg
);
9936 final_type
= result_type
;
9938 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
9939 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
9941 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
9942 && tree_int_cst_sgn (op1
) > 0
9943 /* We can shorten only if the shift count is less than the
9944 number of bits in the smaller type size. */
9945 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
9946 /* We cannot drop an unsigned shift after sign-extension. */
9947 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
9949 /* Do an unsigned shift if the operand was zero-extended. */
9951 = c_common_signed_or_unsigned_type (unsigned_arg
,
9953 /* Convert value-to-be-shifted to that type. */
9954 if (TREE_TYPE (op0
) != result_type
)
9955 op0
= convert (result_type
, op0
);
9960 /* Comparison operations are shortened too but differently.
9961 They identify themselves by setting short_compare = 1. */
9965 /* Don't write &op0, etc., because that would prevent op0
9966 from being kept in a register.
9967 Instead, make copies of the our local variables and
9968 pass the copies by reference, then copy them back afterward. */
9969 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
9970 enum tree_code xresultcode
= resultcode
;
9972 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
9977 goto return_build_binary_op
;
9980 op0
= xop0
, op1
= xop1
;
9982 resultcode
= xresultcode
;
9984 if (c_inhibit_evaluation_warnings
== 0)
9986 bool op0_maybe_const
= true;
9987 bool op1_maybe_const
= true;
9988 tree orig_op0_folded
, orig_op1_folded
;
9990 if (in_late_binary_op
)
9992 orig_op0_folded
= orig_op0
;
9993 orig_op1_folded
= orig_op1
;
9997 /* Fold for the sake of possible warnings, as in
9998 build_conditional_expr. This requires the
9999 "original" values to be folded, not just op0 and
10001 c_inhibit_evaluation_warnings
++;
10002 op0
= c_fully_fold (op0
, require_constant_value
,
10004 op1
= c_fully_fold (op1
, require_constant_value
,
10006 c_inhibit_evaluation_warnings
--;
10007 orig_op0_folded
= c_fully_fold (orig_op0
,
10008 require_constant_value
,
10010 orig_op1_folded
= c_fully_fold (orig_op1
,
10011 require_constant_value
,
10015 if (warn_sign_compare
)
10016 warn_for_sign_compare (location
, orig_op0_folded
,
10017 orig_op1_folded
, op0
, op1
,
10018 result_type
, resultcode
);
10019 if (!in_late_binary_op
)
10021 if (!op0_maybe_const
|| TREE_CODE (op0
) != INTEGER_CST
)
10022 op0
= c_wrap_maybe_const (op0
, !op0_maybe_const
);
10023 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
10024 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
10030 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
10031 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
10032 Then the expression will be built.
10033 It will be given type FINAL_TYPE if that is nonzero;
10034 otherwise, it will be given type RESULT_TYPE. */
10038 binary_op_error (location
, code
, TREE_TYPE (op0
), TREE_TYPE (op1
));
10039 return error_mark_node
;
10042 if (build_type
== NULL_TREE
)
10044 build_type
= result_type
;
10045 if (type0
!= orig_type0
|| type1
!= orig_type1
)
10047 gcc_assert (may_need_excess_precision
&& common
);
10048 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
10054 op0
= ep_convert_and_check (result_type
, op0
, semantic_result_type
);
10055 op1
= ep_convert_and_check (result_type
, op1
, semantic_result_type
);
10057 /* This can happen if one operand has a vector type, and the other
10058 has a different type. */
10059 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
10060 return error_mark_node
;
10063 /* Treat expressions in initializers specially as they can't trap. */
10064 if (int_const_or_overflow
)
10065 ret
= (require_constant_value
10066 ? fold_build2_initializer_loc (location
, resultcode
, build_type
,
10068 : fold_build2_loc (location
, resultcode
, build_type
, op0
, op1
));
10070 ret
= build2 (resultcode
, build_type
, op0
, op1
);
10071 if (final_type
!= 0)
10072 ret
= convert (final_type
, ret
);
10074 return_build_binary_op
:
10075 gcc_assert (ret
!= error_mark_node
);
10076 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
) && !int_const
)
10077 ret
= (int_operands
10078 ? note_integer_operands (ret
)
10079 : build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
));
10080 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
10081 && !in_late_binary_op
)
10082 ret
= note_integer_operands (ret
);
10083 if (semantic_result_type
)
10084 ret
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, ret
);
10085 protected_set_expr_location (ret
, location
);
10090 /* Convert EXPR to be a truth-value, validating its type for this
10091 purpose. LOCATION is the source location for the expression. */
10094 c_objc_common_truthvalue_conversion (location_t location
, tree expr
)
10096 bool int_const
, int_operands
;
10098 switch (TREE_CODE (TREE_TYPE (expr
)))
10101 error_at (location
, "used array that cannot be converted to pointer where scalar is required");
10102 return error_mark_node
;
10105 error_at (location
, "used struct type value where scalar is required");
10106 return error_mark_node
;
10109 error_at (location
, "used union type value where scalar is required");
10110 return error_mark_node
;
10112 case FUNCTION_TYPE
:
10113 gcc_unreachable ();
10119 int_const
= (TREE_CODE (expr
) == INTEGER_CST
&& !TREE_OVERFLOW (expr
));
10120 int_operands
= EXPR_INT_CONST_OPERANDS (expr
);
10122 expr
= remove_c_maybe_const_expr (expr
);
10124 /* ??? Should we also give an error for void and vectors rather than
10125 leaving those to give errors later? */
10126 expr
= c_common_truthvalue_conversion (location
, expr
);
10128 if (TREE_CODE (expr
) == INTEGER_CST
&& int_operands
&& !int_const
)
10130 if (TREE_OVERFLOW (expr
))
10133 return note_integer_operands (expr
);
10135 if (TREE_CODE (expr
) == INTEGER_CST
&& !int_const
)
10136 return build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
10141 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
10145 c_expr_to_decl (tree expr
, bool *tc ATTRIBUTE_UNUSED
, bool *se
)
10147 if (TREE_CODE (expr
) == COMPOUND_LITERAL_EXPR
)
10149 tree decl
= COMPOUND_LITERAL_EXPR_DECL (expr
);
10150 /* Executing a compound literal inside a function reinitializes
10152 if (!TREE_STATIC (decl
))
10160 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10163 c_begin_omp_parallel (void)
10167 keep_next_level ();
10168 block
= c_begin_compound_stmt (true);
10173 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
10174 statement. LOC is the location of the OMP_PARALLEL. */
10177 c_finish_omp_parallel (location_t loc
, tree clauses
, tree block
)
10181 block
= c_end_compound_stmt (loc
, block
, true);
10183 stmt
= make_node (OMP_PARALLEL
);
10184 TREE_TYPE (stmt
) = void_type_node
;
10185 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
10186 OMP_PARALLEL_BODY (stmt
) = block
;
10187 SET_EXPR_LOCATION (stmt
, loc
);
10189 return add_stmt (stmt
);
10192 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10195 c_begin_omp_task (void)
10199 keep_next_level ();
10200 block
= c_begin_compound_stmt (true);
10205 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
10206 statement. LOC is the location of the #pragma. */
10209 c_finish_omp_task (location_t loc
, tree clauses
, tree block
)
10213 block
= c_end_compound_stmt (loc
, block
, true);
10215 stmt
= make_node (OMP_TASK
);
10216 TREE_TYPE (stmt
) = void_type_node
;
10217 OMP_TASK_CLAUSES (stmt
) = clauses
;
10218 OMP_TASK_BODY (stmt
) = block
;
10219 SET_EXPR_LOCATION (stmt
, loc
);
10221 return add_stmt (stmt
);
10224 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
10225 Remove any elements from the list that are invalid. */
10228 c_finish_omp_clauses (tree clauses
)
10230 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
10231 tree c
, t
, *pc
= &clauses
;
10234 bitmap_obstack_initialize (NULL
);
10235 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
10236 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
10237 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
10239 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
10241 bool remove
= false;
10242 bool need_complete
= false;
10243 bool need_implicitly_determined
= false;
10245 switch (OMP_CLAUSE_CODE (c
))
10247 case OMP_CLAUSE_SHARED
:
10249 need_implicitly_determined
= true;
10250 goto check_dup_generic
;
10252 case OMP_CLAUSE_PRIVATE
:
10254 need_complete
= true;
10255 need_implicitly_determined
= true;
10256 goto check_dup_generic
;
10258 case OMP_CLAUSE_REDUCTION
:
10259 name
= "reduction";
10260 need_implicitly_determined
= true;
10261 t
= OMP_CLAUSE_DECL (c
);
10262 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
10263 || POINTER_TYPE_P (TREE_TYPE (t
)))
10265 error_at (OMP_CLAUSE_LOCATION (c
),
10266 "%qE has invalid type for %<reduction%>", t
);
10269 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
10271 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
10272 const char *r_name
= NULL
;
10289 case TRUTH_ANDIF_EXPR
:
10292 case TRUTH_ORIF_EXPR
:
10296 gcc_unreachable ();
10300 error_at (OMP_CLAUSE_LOCATION (c
),
10301 "%qE has invalid type for %<reduction(%s)%>",
10306 goto check_dup_generic
;
10308 case OMP_CLAUSE_COPYPRIVATE
:
10309 name
= "copyprivate";
10310 goto check_dup_generic
;
10312 case OMP_CLAUSE_COPYIN
:
10314 t
= OMP_CLAUSE_DECL (c
);
10315 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
10317 error_at (OMP_CLAUSE_LOCATION (c
),
10318 "%qE must be %<threadprivate%> for %<copyin%>", t
);
10321 goto check_dup_generic
;
10324 t
= OMP_CLAUSE_DECL (c
);
10325 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10327 error_at (OMP_CLAUSE_LOCATION (c
),
10328 "%qE is not a variable in clause %qs", t
, name
);
10331 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
10332 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
10333 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
10335 error_at (OMP_CLAUSE_LOCATION (c
),
10336 "%qE appears more than once in data clauses", t
);
10340 bitmap_set_bit (&generic_head
, DECL_UID (t
));
10343 case OMP_CLAUSE_FIRSTPRIVATE
:
10344 name
= "firstprivate";
10345 t
= OMP_CLAUSE_DECL (c
);
10346 need_complete
= true;
10347 need_implicitly_determined
= true;
10348 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10350 error_at (OMP_CLAUSE_LOCATION (c
),
10351 "%qE is not a variable in clause %<firstprivate%>", t
);
10354 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
10355 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
10357 error_at (OMP_CLAUSE_LOCATION (c
),
10358 "%qE appears more than once in data clauses", t
);
10362 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
10365 case OMP_CLAUSE_LASTPRIVATE
:
10366 name
= "lastprivate";
10367 t
= OMP_CLAUSE_DECL (c
);
10368 need_complete
= true;
10369 need_implicitly_determined
= true;
10370 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10372 error_at (OMP_CLAUSE_LOCATION (c
),
10373 "%qE is not a variable in clause %<lastprivate%>", t
);
10376 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
10377 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
10379 error_at (OMP_CLAUSE_LOCATION (c
),
10380 "%qE appears more than once in data clauses", t
);
10384 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
10387 case OMP_CLAUSE_IF
:
10388 case OMP_CLAUSE_NUM_THREADS
:
10389 case OMP_CLAUSE_SCHEDULE
:
10390 case OMP_CLAUSE_NOWAIT
:
10391 case OMP_CLAUSE_ORDERED
:
10392 case OMP_CLAUSE_DEFAULT
:
10393 case OMP_CLAUSE_UNTIED
:
10394 case OMP_CLAUSE_COLLAPSE
:
10395 pc
= &OMP_CLAUSE_CHAIN (c
);
10399 gcc_unreachable ();
10404 t
= OMP_CLAUSE_DECL (c
);
10408 t
= require_complete_type (t
);
10409 if (t
== error_mark_node
)
10413 if (need_implicitly_determined
)
10415 const char *share_name
= NULL
;
10417 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
10418 share_name
= "threadprivate";
10419 else switch (c_omp_predetermined_sharing (t
))
10421 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
10423 case OMP_CLAUSE_DEFAULT_SHARED
:
10424 share_name
= "shared";
10426 case OMP_CLAUSE_DEFAULT_PRIVATE
:
10427 share_name
= "private";
10430 gcc_unreachable ();
10434 error_at (OMP_CLAUSE_LOCATION (c
),
10435 "%qE is predetermined %qs for %qs",
10436 t
, share_name
, name
);
10443 *pc
= OMP_CLAUSE_CHAIN (c
);
10445 pc
= &OMP_CLAUSE_CHAIN (c
);
10448 bitmap_obstack_release (NULL
);
10452 /* Make a variant type in the proper way for C/C++, propagating qualifiers
10453 down to the element type of an array. */
10456 c_build_qualified_type (tree type
, int type_quals
)
10458 if (type
== error_mark_node
)
10461 if (TREE_CODE (type
) == ARRAY_TYPE
)
10464 tree element_type
= c_build_qualified_type (TREE_TYPE (type
),
10467 /* See if we already have an identically qualified type. */
10468 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10470 if (TYPE_QUALS (strip_array_types (t
)) == type_quals
10471 && TYPE_NAME (t
) == TYPE_NAME (type
)
10472 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
10473 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
10474 TYPE_ATTRIBUTES (type
)))
10479 tree domain
= TYPE_DOMAIN (type
);
10481 t
= build_variant_type_copy (type
);
10482 TREE_TYPE (t
) = element_type
;
10484 if (TYPE_STRUCTURAL_EQUALITY_P (element_type
)
10485 || (domain
&& TYPE_STRUCTURAL_EQUALITY_P (domain
)))
10486 SET_TYPE_STRUCTURAL_EQUALITY (t
);
10487 else if (TYPE_CANONICAL (element_type
) != element_type
10488 || (domain
&& TYPE_CANONICAL (domain
) != domain
))
10490 tree unqualified_canon
10491 = build_array_type (TYPE_CANONICAL (element_type
),
10492 domain
? TYPE_CANONICAL (domain
)
10495 = c_build_qualified_type (unqualified_canon
, type_quals
);
10498 TYPE_CANONICAL (t
) = t
;
10503 /* A restrict-qualified pointer type must be a pointer to object or
10504 incomplete type. Note that the use of POINTER_TYPE_P also allows
10505 REFERENCE_TYPEs, which is appropriate for C++. */
10506 if ((type_quals
& TYPE_QUAL_RESTRICT
)
10507 && (!POINTER_TYPE_P (type
)
10508 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
10510 error ("invalid use of %<restrict%>");
10511 type_quals
&= ~TYPE_QUAL_RESTRICT
;
10514 return build_qualified_type (type
, type_quals
);
10517 /* Build a VA_ARG_EXPR for the C parser. */
10520 c_build_va_arg (location_t loc
, tree expr
, tree type
)
10522 if (warn_cxx_compat
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
10523 warning_at (loc
, OPT_Wc___compat
,
10524 "C++ requires promoted type, not enum type, in %<va_arg%>");
10525 return build_va_arg (loc
, expr
, type
);