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. -Wcast-qual appeared
4417 on the command line. Named address space qualifiers are not handled
4418 here, because they result in different warnings. */
4421 handle_warn_cast_qual (tree type
, tree otype
)
4423 tree in_type
= type
;
4424 tree in_otype
= otype
;
4429 /* Check that the qualifiers on IN_TYPE are a superset of the
4430 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
4431 nodes is uninteresting and we stop as soon as we hit a
4432 non-POINTER_TYPE node on either type. */
4435 in_otype
= TREE_TYPE (in_otype
);
4436 in_type
= TREE_TYPE (in_type
);
4438 /* GNU C allows cv-qualified function types. 'const' means the
4439 function is very pure, 'volatile' means it can't return. We
4440 need to warn when such qualifiers are added, not when they're
4442 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
4443 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
4444 added
|= (TYPE_QUALS_NO_ADDR_SPACE (in_type
)
4445 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype
));
4447 discarded
|= (TYPE_QUALS_NO_ADDR_SPACE (in_otype
)
4448 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type
));
4450 while (TREE_CODE (in_type
) == POINTER_TYPE
4451 && TREE_CODE (in_otype
) == POINTER_TYPE
);
4454 warning (OPT_Wcast_qual
, "cast adds %q#v qualifier to function type",
4458 /* There are qualifiers present in IN_OTYPE that are not present
4460 warning (OPT_Wcast_qual
,
4461 "cast discards %q#v qualifier from pointer target type",
4464 if (added
|| discarded
)
4467 /* A cast from **T to const **T is unsafe, because it can cause a
4468 const value to be changed with no additional warning. We only
4469 issue this warning if T is the same on both sides, and we only
4470 issue the warning if there are the same number of pointers on
4471 both sides, as otherwise the cast is clearly unsafe anyhow. A
4472 cast is unsafe when a qualifier is added at one level and const
4473 is not present at all outer levels.
4475 To issue this warning, we check at each level whether the cast
4476 adds new qualifiers not already seen. We don't need to special
4477 case function types, as they won't have the same
4478 TYPE_MAIN_VARIANT. */
4480 if (TYPE_MAIN_VARIANT (in_type
) != TYPE_MAIN_VARIANT (in_otype
))
4482 if (TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
)
4487 is_const
= TYPE_READONLY (TREE_TYPE (in_type
));
4490 in_type
= TREE_TYPE (in_type
);
4491 in_otype
= TREE_TYPE (in_otype
);
4492 if ((TYPE_QUALS (in_type
) &~ TYPE_QUALS (in_otype
)) != 0
4495 int added
= TYPE_QUALS (in_type
) &~ TYPE_QUALS (in_otype
);
4496 warning (OPT_Wcast_qual
,
4497 ("new %qv qualifier in middle of multi-level non-const cast "
4498 "is unsafe"), added
);
4502 is_const
= TYPE_READONLY (in_type
);
4504 while (TREE_CODE (in_type
) == POINTER_TYPE
);
4507 /* Build an expression representing a cast to type TYPE of expression EXPR.
4508 LOC is the location of the cast-- typically the open paren of the cast. */
4511 build_c_cast (location_t loc
, tree type
, tree expr
)
4515 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
4516 expr
= TREE_OPERAND (expr
, 0);
4520 if (type
== error_mark_node
|| expr
== error_mark_node
)
4521 return error_mark_node
;
4523 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
4524 only in <protocol> qualifications. But when constructing cast expressions,
4525 the protocols do matter and must be kept around. */
4526 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
4527 return build1 (NOP_EXPR
, type
, expr
);
4529 type
= TYPE_MAIN_VARIANT (type
);
4531 if (TREE_CODE (type
) == ARRAY_TYPE
)
4533 error_at (loc
, "cast specifies array type");
4534 return error_mark_node
;
4537 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4539 error_at (loc
, "cast specifies function type");
4540 return error_mark_node
;
4543 if (!VOID_TYPE_P (type
))
4545 value
= require_complete_type (value
);
4546 if (value
== error_mark_node
)
4547 return error_mark_node
;
4550 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
4552 if (TREE_CODE (type
) == RECORD_TYPE
4553 || TREE_CODE (type
) == UNION_TYPE
)
4554 pedwarn (loc
, OPT_pedantic
,
4555 "ISO C forbids casting nonscalar to the same type");
4557 else if (TREE_CODE (type
) == UNION_TYPE
)
4561 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4562 if (TREE_TYPE (field
) != error_mark_node
4563 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
4564 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
4570 bool maybe_const
= true;
4572 pedwarn (loc
, OPT_pedantic
, "ISO C forbids casts to union type");
4573 t
= c_fully_fold (value
, false, &maybe_const
);
4574 t
= build_constructor_single (type
, field
, t
);
4576 t
= c_wrap_maybe_const (t
, true);
4577 t
= digest_init (loc
, type
, t
,
4578 NULL_TREE
, false, true, 0);
4579 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
4582 error_at (loc
, "cast to union type from type not present in union");
4583 return error_mark_node
;
4589 if (type
== void_type_node
)
4591 tree t
= build1 (CONVERT_EXPR
, type
, value
);
4592 SET_EXPR_LOCATION (t
, loc
);
4596 otype
= TREE_TYPE (value
);
4598 /* Optionally warn about potentially worrisome casts. */
4600 && TREE_CODE (type
) == POINTER_TYPE
4601 && TREE_CODE (otype
) == POINTER_TYPE
)
4602 handle_warn_cast_qual (type
, otype
);
4604 /* Warn about conversions between pointers to disjoint
4606 if (TREE_CODE (type
) == POINTER_TYPE
4607 && TREE_CODE (otype
) == POINTER_TYPE
4608 && !null_pointer_constant_p (value
))
4610 addr_space_t as_to
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
4611 addr_space_t as_from
= TYPE_ADDR_SPACE (TREE_TYPE (otype
));
4612 addr_space_t as_common
;
4614 if (!addr_space_superset (as_to
, as_from
, &as_common
))
4616 if (ADDR_SPACE_GENERIC_P (as_from
))
4617 warning_at (loc
, 0, "cast to %s address space pointer "
4618 "from disjoint generic address space pointer",
4619 c_addr_space_name (as_to
));
4621 else if (ADDR_SPACE_GENERIC_P (as_to
))
4622 warning_at (loc
, 0, "cast to generic address space pointer "
4623 "from disjoint %s address space pointer",
4624 c_addr_space_name (as_from
));
4627 warning_at (loc
, 0, "cast to %s address space pointer "
4628 "from disjoint %s address space pointer",
4629 c_addr_space_name (as_to
),
4630 c_addr_space_name (as_from
));
4634 /* Warn about possible alignment problems. */
4635 if (STRICT_ALIGNMENT
4636 && TREE_CODE (type
) == POINTER_TYPE
4637 && TREE_CODE (otype
) == POINTER_TYPE
4638 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
4639 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
4640 /* Don't warn about opaque types, where the actual alignment
4641 restriction is unknown. */
4642 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
4643 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
4644 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
4645 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
4646 warning_at (loc
, OPT_Wcast_align
,
4647 "cast increases required alignment of target type");
4649 if (TREE_CODE (type
) == INTEGER_TYPE
4650 && TREE_CODE (otype
) == POINTER_TYPE
4651 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
4652 /* Unlike conversion of integers to pointers, where the
4653 warning is disabled for converting constants because
4654 of cases such as SIG_*, warn about converting constant
4655 pointers to integers. In some cases it may cause unwanted
4656 sign extension, and a warning is appropriate. */
4657 warning_at (loc
, OPT_Wpointer_to_int_cast
,
4658 "cast from pointer to integer of different size");
4660 if (TREE_CODE (value
) == CALL_EXPR
4661 && TREE_CODE (type
) != TREE_CODE (otype
))
4662 warning_at (loc
, OPT_Wbad_function_cast
,
4663 "cast from function call of type %qT "
4664 "to non-matching type %qT", otype
, type
);
4666 if (TREE_CODE (type
) == POINTER_TYPE
4667 && TREE_CODE (otype
) == INTEGER_TYPE
4668 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
4669 /* Don't warn about converting any constant. */
4670 && !TREE_CONSTANT (value
))
4672 OPT_Wint_to_pointer_cast
, "cast to pointer from integer "
4673 "of different size");
4675 if (warn_strict_aliasing
<= 2)
4676 strict_aliasing_warning (otype
, type
, expr
);
4678 /* If pedantic, warn for conversions between function and object
4679 pointer types, except for converting a null pointer constant
4680 to function pointer type. */
4682 && TREE_CODE (type
) == POINTER_TYPE
4683 && TREE_CODE (otype
) == POINTER_TYPE
4684 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
4685 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
4686 pedwarn (loc
, OPT_pedantic
, "ISO C forbids "
4687 "conversion of function pointer to object pointer type");
4690 && TREE_CODE (type
) == POINTER_TYPE
4691 && TREE_CODE (otype
) == POINTER_TYPE
4692 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
4693 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
4694 && !null_pointer_constant_p (value
))
4695 pedwarn (loc
, OPT_pedantic
, "ISO C forbids "
4696 "conversion of object pointer to function pointer type");
4699 value
= convert (type
, value
);
4701 /* Ignore any integer overflow caused by the cast. */
4702 if (TREE_CODE (value
) == INTEGER_CST
&& !FLOAT_TYPE_P (otype
))
4704 if (CONSTANT_CLASS_P (ovalue
) && TREE_OVERFLOW (ovalue
))
4706 if (!TREE_OVERFLOW (value
))
4708 /* Avoid clobbering a shared constant. */
4709 value
= copy_node (value
);
4710 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
4713 else if (TREE_OVERFLOW (value
))
4714 /* Reset VALUE's overflow flags, ensuring constant sharing. */
4715 value
= build_int_cst_wide (TREE_TYPE (value
),
4716 TREE_INT_CST_LOW (value
),
4717 TREE_INT_CST_HIGH (value
));
4721 /* Don't let a cast be an lvalue. */
4723 value
= non_lvalue_loc (loc
, value
);
4725 /* Don't allow the results of casting to floating-point or complex
4726 types be confused with actual constants, or casts involving
4727 integer and pointer types other than direct integer-to-integer
4728 and integer-to-pointer be confused with integer constant
4729 expressions and null pointer constants. */
4730 if (TREE_CODE (value
) == REAL_CST
4731 || TREE_CODE (value
) == COMPLEX_CST
4732 || (TREE_CODE (value
) == INTEGER_CST
4733 && !((TREE_CODE (expr
) == INTEGER_CST
4734 && INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
4735 || TREE_CODE (expr
) == REAL_CST
4736 || TREE_CODE (expr
) == COMPLEX_CST
)))
4737 value
= build1 (NOP_EXPR
, type
, value
);
4739 if (CAN_HAVE_LOCATION_P (value
))
4740 SET_EXPR_LOCATION (value
, loc
);
4744 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
4745 location of the open paren of the cast, or the position of the cast
4748 c_cast_expr (location_t loc
, struct c_type_name
*type_name
, tree expr
)
4751 tree type_expr
= NULL_TREE
;
4752 bool type_expr_const
= true;
4754 int saved_wsp
= warn_strict_prototypes
;
4756 /* This avoids warnings about unprototyped casts on
4757 integers. E.g. "#define SIG_DFL (void(*)())0". */
4758 if (TREE_CODE (expr
) == INTEGER_CST
)
4759 warn_strict_prototypes
= 0;
4760 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
4761 warn_strict_prototypes
= saved_wsp
;
4763 ret
= build_c_cast (loc
, type
, expr
);
4766 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
), type_expr
, ret
);
4767 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = !type_expr_const
;
4768 SET_EXPR_LOCATION (ret
, loc
);
4771 if (CAN_HAVE_LOCATION_P (ret
) && !EXPR_HAS_LOCATION (ret
))
4772 SET_EXPR_LOCATION (ret
, loc
);
4774 /* C++ does not permits types to be defined in a cast. */
4775 if (warn_cxx_compat
&& type_name
->specs
->tag_defined_p
)
4776 warning_at (loc
, OPT_Wc___compat
,
4777 "defining a type in a cast is invalid in C++");
4782 /* Build an assignment expression of lvalue LHS from value RHS.
4783 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
4784 may differ from TREE_TYPE (LHS) for an enum bitfield.
4785 MODIFYCODE is the code for a binary operator that we use
4786 to combine the old value of LHS with RHS to get the new value.
4787 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4788 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
4789 which may differ from TREE_TYPE (RHS) for an enum value.
4791 LOCATION is the location of the MODIFYCODE operator.
4792 RHS_LOC is the location of the RHS. */
4795 build_modify_expr (location_t location
, tree lhs
, tree lhs_origtype
,
4796 enum tree_code modifycode
,
4797 location_t rhs_loc
, tree rhs
, tree rhs_origtype
)
4801 tree rhs_semantic_type
= NULL_TREE
;
4802 tree lhstype
= TREE_TYPE (lhs
);
4803 tree olhstype
= lhstype
;
4806 /* Types that aren't fully specified cannot be used in assignments. */
4807 lhs
= require_complete_type (lhs
);
4809 /* Avoid duplicate error messages from operands that had errors. */
4810 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
4811 return error_mark_node
;
4813 if (!lvalue_or_else (lhs
, lv_assign
))
4814 return error_mark_node
;
4816 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
4818 rhs_semantic_type
= TREE_TYPE (rhs
);
4819 rhs
= TREE_OPERAND (rhs
, 0);
4824 if (TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
4826 tree inner
= build_modify_expr (location
, C_MAYBE_CONST_EXPR_EXPR (lhs
),
4827 lhs_origtype
, modifycode
, rhs_loc
, rhs
,
4829 if (inner
== error_mark_node
)
4830 return error_mark_node
;
4831 result
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
4832 C_MAYBE_CONST_EXPR_PRE (lhs
), inner
);
4833 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs
));
4834 C_MAYBE_CONST_EXPR_NON_CONST (result
) = 1;
4835 protected_set_expr_location (result
, location
);
4839 /* If a binary op has been requested, combine the old LHS value with the RHS
4840 producing the value we should actually store into the LHS. */
4842 if (modifycode
!= NOP_EXPR
)
4844 lhs
= c_fully_fold (lhs
, false, NULL
);
4845 lhs
= stabilize_reference (lhs
);
4846 newrhs
= build_binary_op (location
,
4847 modifycode
, lhs
, rhs
, 1);
4849 /* The original type of the right hand side is no longer
4851 rhs_origtype
= NULL_TREE
;
4854 /* Give an error for storing in something that is 'const'. */
4856 if (TYPE_READONLY (lhstype
)
4857 || ((TREE_CODE (lhstype
) == RECORD_TYPE
4858 || TREE_CODE (lhstype
) == UNION_TYPE
)
4859 && C_TYPE_FIELDS_READONLY (lhstype
)))
4861 readonly_error (lhs
, lv_assign
);
4862 return error_mark_node
;
4864 else if (TREE_READONLY (lhs
))
4865 readonly_warning (lhs
, lv_assign
);
4867 /* If storing into a structure or union member,
4868 it has probably been given type `int'.
4869 Compute the type that would go with
4870 the actual amount of storage the member occupies. */
4872 if (TREE_CODE (lhs
) == COMPONENT_REF
4873 && (TREE_CODE (lhstype
) == INTEGER_TYPE
4874 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
4875 || TREE_CODE (lhstype
) == REAL_TYPE
4876 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
4877 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
4879 /* If storing in a field that is in actuality a short or narrower than one,
4880 we must store in the field in its actual type. */
4882 if (lhstype
!= TREE_TYPE (lhs
))
4884 lhs
= copy_node (lhs
);
4885 TREE_TYPE (lhs
) = lhstype
;
4888 /* Issue -Wc++-compat warnings about an assignment to an enum type
4889 when LHS does not have its original type. This happens for,
4890 e.g., an enum bitfield in a struct. */
4892 && lhs_origtype
!= NULL_TREE
4893 && lhs_origtype
!= lhstype
4894 && TREE_CODE (lhs_origtype
) == ENUMERAL_TYPE
)
4896 tree checktype
= (rhs_origtype
!= NULL_TREE
4899 if (checktype
!= error_mark_node
4900 && TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (lhs_origtype
))
4901 warning_at (location
, OPT_Wc___compat
,
4902 "enum conversion in assignment is invalid in C++");
4905 /* Convert new value to destination type. Fold it first, then
4906 restore any excess precision information, for the sake of
4907 conversion warnings. */
4909 npc
= null_pointer_constant_p (newrhs
);
4910 newrhs
= c_fully_fold (newrhs
, false, NULL
);
4911 if (rhs_semantic_type
)
4912 newrhs
= build1 (EXCESS_PRECISION_EXPR
, rhs_semantic_type
, newrhs
);
4913 newrhs
= convert_for_assignment (location
, lhstype
, newrhs
, rhs_origtype
,
4914 ic_assign
, npc
, NULL_TREE
, NULL_TREE
, 0);
4915 if (TREE_CODE (newrhs
) == ERROR_MARK
)
4916 return error_mark_node
;
4918 /* Emit ObjC write barrier, if necessary. */
4919 if (c_dialect_objc () && flag_objc_gc
)
4921 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
4924 protected_set_expr_location (result
, location
);
4929 /* Scan operands. */
4931 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
4932 TREE_SIDE_EFFECTS (result
) = 1;
4933 protected_set_expr_location (result
, location
);
4935 /* If we got the LHS in a different type for storing in,
4936 convert the result back to the nominal type of LHS
4937 so that the value we return always has the same type
4938 as the LHS argument. */
4940 if (olhstype
== TREE_TYPE (result
))
4943 result
= convert_for_assignment (location
, olhstype
, result
, rhs_origtype
,
4944 ic_assign
, false, NULL_TREE
, NULL_TREE
, 0);
4945 protected_set_expr_location (result
, location
);
4949 /* Convert value RHS to type TYPE as preparation for an assignment to
4950 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
4951 original type of RHS; this differs from TREE_TYPE (RHS) for enum
4952 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
4953 constant before any folding.
4954 The real work of conversion is done by `convert'.
4955 The purpose of this function is to generate error messages
4956 for assignments that are not allowed in C.
4957 ERRTYPE says whether it is argument passing, assignment,
4958 initialization or return.
4960 LOCATION is the location of the RHS.
4961 FUNCTION is a tree for the function being called.
4962 PARMNUM is the number of the argument, for printing in error messages. */
4965 convert_for_assignment (location_t location
, tree type
, tree rhs
,
4966 tree origtype
, enum impl_conv errtype
,
4967 bool null_pointer_constant
, tree fundecl
,
4968 tree function
, int parmnum
)
4970 enum tree_code codel
= TREE_CODE (type
);
4971 tree orig_rhs
= rhs
;
4973 enum tree_code coder
;
4974 tree rname
= NULL_TREE
;
4975 bool objc_ok
= false;
4977 if (errtype
== ic_argpass
)
4980 /* Change pointer to function to the function itself for
4982 if (TREE_CODE (function
) == ADDR_EXPR
4983 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
4984 function
= TREE_OPERAND (function
, 0);
4986 /* Handle an ObjC selector specially for diagnostics. */
4987 selector
= objc_message_selector ();
4989 if (selector
&& parmnum
> 2)
4996 /* This macro is used to emit diagnostics to ensure that all format
4997 strings are complete sentences, visible to gettext and checked at
4999 #define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE) \
5004 if (pedwarn (LOCATION, OPT, AR, parmnum, rname)) \
5005 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5006 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5007 "expected %qT but argument is of type %qT", \
5011 pedwarn (LOCATION, OPT, AS); \
5014 pedwarn (LOCATION, OPT, IN); \
5017 pedwarn (LOCATION, OPT, RE); \
5020 gcc_unreachable (); \
5024 /* This macro is used to emit diagnostics to ensure that all format
5025 strings are complete sentences, visible to gettext and checked at
5026 compile time. It is the same as WARN_FOR_ASSIGNMENT but with an
5027 extra parameter to enumerate qualifiers. */
5029 #define WARN_FOR_QUALIFIERS(LOCATION, OPT, AR, AS, IN, RE, QUALS) \
5034 if (pedwarn (LOCATION, OPT, AR, parmnum, rname, QUALS)) \
5035 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5036 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5037 "expected %qT but argument is of type %qT", \
5041 pedwarn (LOCATION, OPT, AS, QUALS); \
5044 pedwarn (LOCATION, OPT, IN, QUALS); \
5047 pedwarn (LOCATION, OPT, RE, QUALS); \
5050 gcc_unreachable (); \
5054 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
5055 rhs
= TREE_OPERAND (rhs
, 0);
5057 rhstype
= TREE_TYPE (rhs
);
5058 coder
= TREE_CODE (rhstype
);
5060 if (coder
== ERROR_MARK
)
5061 return error_mark_node
;
5063 if (c_dialect_objc ())
5086 objc_ok
= objc_compare_types (type
, rhstype
, parmno
, rname
);
5089 if (warn_cxx_compat
)
5091 tree checktype
= origtype
!= NULL_TREE
? origtype
: rhstype
;
5092 if (checktype
!= error_mark_node
5093 && TREE_CODE (type
) == ENUMERAL_TYPE
5094 && TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (type
))
5096 WARN_FOR_ASSIGNMENT (input_location
, OPT_Wc___compat
,
5097 G_("enum conversion when passing argument "
5098 "%d of %qE is invalid in C++"),
5099 G_("enum conversion in assignment is "
5101 G_("enum conversion in initialization is "
5103 G_("enum conversion in return is "
5108 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
5111 if (coder
== VOID_TYPE
)
5113 /* Except for passing an argument to an unprototyped function,
5114 this is a constraint violation. When passing an argument to
5115 an unprototyped function, it is compile-time undefined;
5116 making it a constraint in that case was rejected in
5118 error_at (location
, "void value not ignored as it ought to be");
5119 return error_mark_node
;
5121 rhs
= require_complete_type (rhs
);
5122 if (rhs
== error_mark_node
)
5123 return error_mark_node
;
5124 /* A type converts to a reference to it.
5125 This code doesn't fully support references, it's just for the
5126 special case of va_start and va_copy. */
5127 if (codel
== REFERENCE_TYPE
5128 && comptypes (TREE_TYPE (type
), TREE_TYPE (rhs
)) == 1)
5130 if (!lvalue_p (rhs
))
5132 error_at (location
, "cannot pass rvalue to reference parameter");
5133 return error_mark_node
;
5135 if (!c_mark_addressable (rhs
))
5136 return error_mark_node
;
5137 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
5138 SET_EXPR_LOCATION (rhs
, location
);
5140 /* We already know that these two types are compatible, but they
5141 may not be exactly identical. In fact, `TREE_TYPE (type)' is
5142 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
5143 likely to be va_list, a typedef to __builtin_va_list, which
5144 is different enough that it will cause problems later. */
5145 if (TREE_TYPE (TREE_TYPE (rhs
)) != TREE_TYPE (type
))
5147 rhs
= build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), rhs
);
5148 SET_EXPR_LOCATION (rhs
, location
);
5151 rhs
= build1 (NOP_EXPR
, type
, rhs
);
5152 SET_EXPR_LOCATION (rhs
, location
);
5155 /* Some types can interconvert without explicit casts. */
5156 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
5157 && vector_types_convertible_p (type
, TREE_TYPE (rhs
), true))
5158 return convert (type
, rhs
);
5159 /* Arithmetic types all interconvert, and enum is treated like int. */
5160 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
5161 || codel
== FIXED_POINT_TYPE
5162 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
5163 || codel
== BOOLEAN_TYPE
)
5164 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
5165 || coder
== FIXED_POINT_TYPE
5166 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
5167 || coder
== BOOLEAN_TYPE
))
5170 bool save
= in_late_binary_op
;
5171 if (codel
== BOOLEAN_TYPE
)
5172 in_late_binary_op
= true;
5173 ret
= convert_and_check (type
, orig_rhs
);
5174 if (codel
== BOOLEAN_TYPE
)
5175 in_late_binary_op
= save
;
5179 /* Aggregates in different TUs might need conversion. */
5180 if ((codel
== RECORD_TYPE
|| codel
== UNION_TYPE
)
5182 && comptypes (type
, rhstype
))
5183 return convert_and_check (type
, rhs
);
5185 /* Conversion to a transparent union or record from its member types.
5186 This applies only to function arguments. */
5187 if (((codel
== UNION_TYPE
|| codel
== RECORD_TYPE
)
5188 && TYPE_TRANSPARENT_AGGR (type
))
5189 && errtype
== ic_argpass
)
5191 tree memb
, marginal_memb
= NULL_TREE
;
5193 for (memb
= TYPE_FIELDS (type
); memb
; memb
= TREE_CHAIN (memb
))
5195 tree memb_type
= TREE_TYPE (memb
);
5197 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
5198 TYPE_MAIN_VARIANT (rhstype
)))
5201 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
5204 if (coder
== POINTER_TYPE
)
5206 tree ttl
= TREE_TYPE (memb_type
);
5207 tree ttr
= TREE_TYPE (rhstype
);
5209 /* Any non-function converts to a [const][volatile] void *
5210 and vice versa; otherwise, targets must be the same.
5211 Meanwhile, the lhs target must have all the qualifiers of
5213 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
5214 || comp_target_types (location
, memb_type
, rhstype
))
5216 /* If this type won't generate any warnings, use it. */
5217 if (TYPE_QUALS (ttl
) == TYPE_QUALS (ttr
)
5218 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
5219 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
5220 ? ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
5221 == TYPE_QUALS (ttr
))
5222 : ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
5223 == TYPE_QUALS (ttl
))))
5226 /* Keep looking for a better type, but remember this one. */
5228 marginal_memb
= memb
;
5232 /* Can convert integer zero to any pointer type. */
5233 if (null_pointer_constant
)
5235 rhs
= null_pointer_node
;
5240 if (memb
|| marginal_memb
)
5244 /* We have only a marginally acceptable member type;
5245 it needs a warning. */
5246 tree ttl
= TREE_TYPE (TREE_TYPE (marginal_memb
));
5247 tree ttr
= TREE_TYPE (rhstype
);
5249 /* Const and volatile mean something different for function
5250 types, so the usual warnings are not appropriate. */
5251 if (TREE_CODE (ttr
) == FUNCTION_TYPE
5252 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
5254 /* Because const and volatile on functions are
5255 restrictions that say the function will not do
5256 certain things, it is okay to use a const or volatile
5257 function where an ordinary one is wanted, but not
5259 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
5260 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
5261 WARN_FOR_QUALIFIERS (location
, 0,
5262 G_("passing argument %d of %qE "
5263 "makes %q#v qualified function "
5264 "pointer from unqualified"),
5265 G_("assignment makes %q#v qualified "
5266 "function pointer from "
5268 G_("initialization makes %q#v qualified "
5269 "function pointer from "
5271 G_("return makes %q#v qualified function "
5272 "pointer from unqualified"),
5273 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
5275 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr
)
5276 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl
))
5277 WARN_FOR_QUALIFIERS (location
, 0,
5278 G_("passing argument %d of %qE discards "
5279 "%qv qualifier from pointer target type"),
5280 G_("assignment discards %qv qualifier "
5281 "from pointer target type"),
5282 G_("initialization discards %qv qualifier "
5283 "from pointer target type"),
5284 G_("return discards %qv qualifier from "
5285 "pointer target type"),
5286 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
5288 memb
= marginal_memb
;
5291 if (!fundecl
|| !DECL_IN_SYSTEM_HEADER (fundecl
))
5292 pedwarn (location
, OPT_pedantic
,
5293 "ISO C prohibits argument conversion to union type");
5295 rhs
= fold_convert_loc (location
, TREE_TYPE (memb
), rhs
);
5296 return build_constructor_single (type
, memb
, rhs
);
5300 /* Conversions among pointers */
5301 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
5302 && (coder
== codel
))
5304 tree ttl
= TREE_TYPE (type
);
5305 tree ttr
= TREE_TYPE (rhstype
);
5308 bool is_opaque_pointer
;
5309 int target_cmp
= 0; /* Cache comp_target_types () result. */
5313 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
5314 mvl
= TYPE_MAIN_VARIANT (mvl
);
5315 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
5316 mvr
= TYPE_MAIN_VARIANT (mvr
);
5317 /* Opaque pointers are treated like void pointers. */
5318 is_opaque_pointer
= vector_targets_convertible_p (ttl
, ttr
);
5320 /* C++ does not allow the implicit conversion void* -> T*. However,
5321 for the purpose of reducing the number of false positives, we
5322 tolerate the special case of
5326 where NULL is typically defined in C to be '(void *) 0'. */
5327 if (VOID_TYPE_P (ttr
) && rhs
!= null_pointer_node
&& !VOID_TYPE_P (ttl
))
5328 warning_at (location
, OPT_Wc___compat
,
5329 "request for implicit conversion "
5330 "from %qT to %qT not permitted in C++", rhstype
, type
);
5332 /* See if the pointers point to incompatible address spaces. */
5333 asl
= TYPE_ADDR_SPACE (ttl
);
5334 asr
= TYPE_ADDR_SPACE (ttr
);
5335 if (!null_pointer_constant_p (rhs
)
5336 && asr
!= asl
&& !targetm
.addr_space
.subset_p (asr
, asl
))
5341 error_at (location
, "passing argument %d of %qE from pointer to "
5342 "non-enclosed address space", parmnum
, rname
);
5345 error_at (location
, "assignment from pointer to "
5346 "non-enclosed address space");
5349 error_at (location
, "initialization from pointer to "
5350 "non-enclosed address space");
5353 error_at (location
, "return from pointer to "
5354 "non-enclosed address space");
5359 return error_mark_node
;
5362 /* Check if the right-hand side has a format attribute but the
5363 left-hand side doesn't. */
5364 if (warn_missing_format_attribute
5365 && check_missing_format_attribute (type
, rhstype
))
5370 warning_at (location
, OPT_Wmissing_format_attribute
,
5371 "argument %d of %qE might be "
5372 "a candidate for a format attribute",
5376 warning_at (location
, OPT_Wmissing_format_attribute
,
5377 "assignment left-hand side might be "
5378 "a candidate for a format attribute");
5381 warning_at (location
, OPT_Wmissing_format_attribute
,
5382 "initialization left-hand side might be "
5383 "a candidate for a format attribute");
5386 warning_at (location
, OPT_Wmissing_format_attribute
,
5387 "return type might be "
5388 "a candidate for a format attribute");
5395 /* Any non-function converts to a [const][volatile] void *
5396 and vice versa; otherwise, targets must be the same.
5397 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
5398 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
5399 || (target_cmp
= comp_target_types (location
, type
, rhstype
))
5400 || is_opaque_pointer
5401 || (c_common_unsigned_type (mvl
)
5402 == c_common_unsigned_type (mvr
)))
5405 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
5408 && !null_pointer_constant
5409 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
5410 WARN_FOR_ASSIGNMENT (location
, OPT_pedantic
,
5411 G_("ISO C forbids passing argument %d of "
5412 "%qE between function pointer "
5414 G_("ISO C forbids assignment between "
5415 "function pointer and %<void *%>"),
5416 G_("ISO C forbids initialization between "
5417 "function pointer and %<void *%>"),
5418 G_("ISO C forbids return between function "
5419 "pointer and %<void *%>"));
5420 /* Const and volatile mean something different for function types,
5421 so the usual warnings are not appropriate. */
5422 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
5423 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
5425 if (TYPE_QUALS_NO_ADDR_SPACE (ttr
)
5426 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl
))
5428 /* Types differing only by the presence of the 'volatile'
5429 qualifier are acceptable if the 'volatile' has been added
5430 in by the Objective-C EH machinery. */
5431 if (!objc_type_quals_match (ttl
, ttr
))
5432 WARN_FOR_QUALIFIERS (location
, 0,
5433 G_("passing argument %d of %qE discards "
5434 "%qv qualifier from pointer target type"),
5435 G_("assignment discards %qv qualifier "
5436 "from pointer target type"),
5437 G_("initialization discards %qv qualifier "
5438 "from pointer target type"),
5439 G_("return discards %qv qualifier from "
5440 "pointer target type"),
5441 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
5443 /* If this is not a case of ignoring a mismatch in signedness,
5445 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
5448 /* If there is a mismatch, do warn. */
5449 else if (warn_pointer_sign
)
5450 WARN_FOR_ASSIGNMENT (location
, OPT_Wpointer_sign
,
5451 G_("pointer targets in passing argument "
5452 "%d of %qE differ in signedness"),
5453 G_("pointer targets in assignment "
5454 "differ in signedness"),
5455 G_("pointer targets in initialization "
5456 "differ in signedness"),
5457 G_("pointer targets in return differ "
5460 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
5461 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
5463 /* Because const and volatile on functions are restrictions
5464 that say the function will not do certain things,
5465 it is okay to use a const or volatile function
5466 where an ordinary one is wanted, but not vice-versa. */
5467 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
5468 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
5469 WARN_FOR_QUALIFIERS (location
, 0,
5470 G_("passing argument %d of %qE makes "
5471 "%q#v qualified function pointer "
5472 "from unqualified"),
5473 G_("assignment makes %q#v qualified function "
5474 "pointer from unqualified"),
5475 G_("initialization makes %q#v qualified "
5476 "function pointer from unqualified"),
5477 G_("return makes %q#v qualified function "
5478 "pointer from unqualified"),
5479 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
5483 /* Avoid warning about the volatile ObjC EH puts on decls. */
5485 WARN_FOR_ASSIGNMENT (location
, 0,
5486 G_("passing argument %d of %qE from "
5487 "incompatible pointer type"),
5488 G_("assignment from incompatible pointer type"),
5489 G_("initialization from incompatible "
5491 G_("return from incompatible pointer type"));
5493 return convert (type
, rhs
);
5495 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
5497 /* ??? This should not be an error when inlining calls to
5498 unprototyped functions. */
5499 error_at (location
, "invalid use of non-lvalue array");
5500 return error_mark_node
;
5502 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
5504 /* An explicit constant 0 can convert to a pointer,
5505 or one that results from arithmetic, even including
5506 a cast to integer type. */
5507 if (!null_pointer_constant
)
5508 WARN_FOR_ASSIGNMENT (location
, 0,
5509 G_("passing argument %d of %qE makes "
5510 "pointer from integer without a cast"),
5511 G_("assignment makes pointer from integer "
5513 G_("initialization makes pointer from "
5514 "integer without a cast"),
5515 G_("return makes pointer from integer "
5518 return convert (type
, rhs
);
5520 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
5522 WARN_FOR_ASSIGNMENT (location
, 0,
5523 G_("passing argument %d of %qE makes integer "
5524 "from pointer without a cast"),
5525 G_("assignment makes integer from pointer "
5527 G_("initialization makes integer from pointer "
5529 G_("return makes integer from pointer "
5531 return convert (type
, rhs
);
5533 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
5536 bool save
= in_late_binary_op
;
5537 in_late_binary_op
= true;
5538 ret
= convert (type
, rhs
);
5539 in_late_binary_op
= save
;
5546 error_at (location
, "incompatible type for argument %d of %qE", parmnum
, rname
);
5547 inform ((fundecl
&& !DECL_IS_BUILTIN (fundecl
))
5548 ? DECL_SOURCE_LOCATION (fundecl
) : input_location
,
5549 "expected %qT but argument is of type %qT", type
, rhstype
);
5552 error_at (location
, "incompatible types when assigning to type %qT from "
5553 "type %qT", type
, rhstype
);
5557 "incompatible types when initializing type %qT using type %qT",
5562 "incompatible types when returning type %qT but %qT was "
5563 "expected", rhstype
, type
);
5569 return error_mark_node
;
5572 /* If VALUE is a compound expr all of whose expressions are constant, then
5573 return its value. Otherwise, return error_mark_node.
5575 This is for handling COMPOUND_EXPRs as initializer elements
5576 which is allowed with a warning when -pedantic is specified. */
5579 valid_compound_expr_initializer (tree value
, tree endtype
)
5581 if (TREE_CODE (value
) == COMPOUND_EXPR
)
5583 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
5585 return error_mark_node
;
5586 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
5589 else if (!initializer_constant_valid_p (value
, endtype
))
5590 return error_mark_node
;
5595 /* Perform appropriate conversions on the initial value of a variable,
5596 store it in the declaration DECL,
5597 and print any error messages that are appropriate.
5598 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5599 If the init is invalid, store an ERROR_MARK.
5601 INIT_LOC is the location of the initial value. */
5604 store_init_value (location_t init_loc
, tree decl
, tree init
, tree origtype
)
5609 /* If variable's type was invalidly declared, just ignore it. */
5611 type
= TREE_TYPE (decl
);
5612 if (TREE_CODE (type
) == ERROR_MARK
)
5615 /* Digest the specified initializer into an expression. */
5618 npc
= null_pointer_constant_p (init
);
5619 value
= digest_init (init_loc
, type
, init
, origtype
, npc
,
5620 true, TREE_STATIC (decl
));
5622 /* Store the expression if valid; else report error. */
5624 if (!in_system_header
5625 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
5626 warning (OPT_Wtraditional
, "traditional C rejects automatic "
5627 "aggregate initialization");
5629 DECL_INITIAL (decl
) = value
;
5631 /* ANSI wants warnings about out-of-range constant initializers. */
5632 STRIP_TYPE_NOPS (value
);
5633 if (TREE_STATIC (decl
))
5634 constant_expression_warning (value
);
5636 /* Check if we need to set array size from compound literal size. */
5637 if (TREE_CODE (type
) == ARRAY_TYPE
5638 && TYPE_DOMAIN (type
) == 0
5639 && value
!= error_mark_node
)
5641 tree inside_init
= init
;
5643 STRIP_TYPE_NOPS (inside_init
);
5644 inside_init
= fold (inside_init
);
5646 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
5648 tree cldecl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
5650 if (TYPE_DOMAIN (TREE_TYPE (cldecl
)))
5652 /* For int foo[] = (int [3]){1}; we need to set array size
5653 now since later on array initializer will be just the
5654 brace enclosed list of the compound literal. */
5655 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5656 TREE_TYPE (decl
) = type
;
5657 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (cldecl
));
5659 layout_decl (cldecl
, 0);
5665 /* Methods for storing and printing names for error messages. */
5667 /* Implement a spelling stack that allows components of a name to be pushed
5668 and popped. Each element on the stack is this structure. */
5675 unsigned HOST_WIDE_INT i
;
5680 #define SPELLING_STRING 1
5681 #define SPELLING_MEMBER 2
5682 #define SPELLING_BOUNDS 3
5684 static struct spelling
*spelling
; /* Next stack element (unused). */
5685 static struct spelling
*spelling_base
; /* Spelling stack base. */
5686 static int spelling_size
; /* Size of the spelling stack. */
5688 /* Macros to save and restore the spelling stack around push_... functions.
5689 Alternative to SAVE_SPELLING_STACK. */
5691 #define SPELLING_DEPTH() (spelling - spelling_base)
5692 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
5694 /* Push an element on the spelling stack with type KIND and assign VALUE
5697 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
5699 int depth = SPELLING_DEPTH (); \
5701 if (depth >= spelling_size) \
5703 spelling_size += 10; \
5704 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
5706 RESTORE_SPELLING_DEPTH (depth); \
5709 spelling->kind = (KIND); \
5710 spelling->MEMBER = (VALUE); \
5714 /* Push STRING on the stack. Printed literally. */
5717 push_string (const char *string
)
5719 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
5722 /* Push a member name on the stack. Printed as '.' STRING. */
5725 push_member_name (tree decl
)
5727 const char *const string
5729 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)))
5730 : _("<anonymous>"));
5731 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
5734 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
5737 push_array_bounds (unsigned HOST_WIDE_INT bounds
)
5739 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
5742 /* Compute the maximum size in bytes of the printed spelling. */
5745 spelling_length (void)
5750 for (p
= spelling_base
; p
< spelling
; p
++)
5752 if (p
->kind
== SPELLING_BOUNDS
)
5755 size
+= strlen (p
->u
.s
) + 1;
5761 /* Print the spelling to BUFFER and return it. */
5764 print_spelling (char *buffer
)
5769 for (p
= spelling_base
; p
< spelling
; p
++)
5770 if (p
->kind
== SPELLING_BOUNDS
)
5772 sprintf (d
, "[" HOST_WIDE_INT_PRINT_UNSIGNED
"]", p
->u
.i
);
5778 if (p
->kind
== SPELLING_MEMBER
)
5780 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
5787 /* Issue an error message for a bad initializer component.
5788 MSGID identifies the message.
5789 The component name is taken from the spelling stack. */
5792 error_init (const char *msgid
)
5796 error ("%s", _(msgid
));
5797 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5799 error ("(near initialization for %qs)", ofwhat
);
5802 /* Issue a pedantic warning for a bad initializer component. OPT is
5803 the option OPT_* (from options.h) controlling this warning or 0 if
5804 it is unconditionally given. MSGID identifies the message. The
5805 component name is taken from the spelling stack. */
5808 pedwarn_init (location_t location
, int opt
, const char *msgid
)
5812 pedwarn (location
, opt
, "%s", _(msgid
));
5813 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5815 pedwarn (location
, opt
, "(near initialization for %qs)", ofwhat
);
5818 /* Issue a warning for a bad initializer component.
5820 OPT is the OPT_W* value corresponding to the warning option that
5821 controls this warning. MSGID identifies the message. The
5822 component name is taken from the spelling stack. */
5825 warning_init (int opt
, const char *msgid
)
5829 warning (opt
, "%s", _(msgid
));
5830 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5832 warning (opt
, "(near initialization for %qs)", ofwhat
);
5835 /* If TYPE is an array type and EXPR is a parenthesized string
5836 constant, warn if pedantic that EXPR is being used to initialize an
5837 object of type TYPE. */
5840 maybe_warn_string_init (tree type
, struct c_expr expr
)
5843 && TREE_CODE (type
) == ARRAY_TYPE
5844 && TREE_CODE (expr
.value
) == STRING_CST
5845 && expr
.original_code
!= STRING_CST
)
5846 pedwarn_init (input_location
, OPT_pedantic
,
5847 "array initialized from parenthesized string constant");
5850 /* Digest the parser output INIT as an initializer for type TYPE.
5851 Return a C expression of type TYPE to represent the initial value.
5853 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5855 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
5857 If INIT is a string constant, STRICT_STRING is true if it is
5858 unparenthesized or we should not warn here for it being parenthesized.
5859 For other types of INIT, STRICT_STRING is not used.
5861 INIT_LOC is the location of the INIT.
5863 REQUIRE_CONSTANT requests an error if non-constant initializers or
5864 elements are seen. */
5867 digest_init (location_t init_loc
, tree type
, tree init
, tree origtype
,
5868 bool null_pointer_constant
, bool strict_string
,
5869 int require_constant
)
5871 enum tree_code code
= TREE_CODE (type
);
5872 tree inside_init
= init
;
5873 tree semantic_type
= NULL_TREE
;
5874 bool maybe_const
= true;
5876 if (type
== error_mark_node
5878 || init
== error_mark_node
5879 || TREE_TYPE (init
) == error_mark_node
)
5880 return error_mark_node
;
5882 STRIP_TYPE_NOPS (inside_init
);
5884 if (TREE_CODE (inside_init
) == EXCESS_PRECISION_EXPR
)
5886 semantic_type
= TREE_TYPE (inside_init
);
5887 inside_init
= TREE_OPERAND (inside_init
, 0);
5889 inside_init
= c_fully_fold (inside_init
, require_constant
, &maybe_const
);
5890 inside_init
= decl_constant_value_for_optimization (inside_init
);
5892 /* Initialization of an array of chars from a string constant
5893 optionally enclosed in braces. */
5895 if (code
== ARRAY_TYPE
&& inside_init
5896 && TREE_CODE (inside_init
) == STRING_CST
)
5898 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
5899 /* Note that an array could be both an array of character type
5900 and an array of wchar_t if wchar_t is signed char or unsigned
5902 bool char_array
= (typ1
== char_type_node
5903 || typ1
== signed_char_type_node
5904 || typ1
== unsigned_char_type_node
);
5905 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
5906 bool char16_array
= !!comptypes (typ1
, char16_type_node
);
5907 bool char32_array
= !!comptypes (typ1
, char32_type_node
);
5909 if (char_array
|| wchar_array
|| char16_array
|| char32_array
)
5912 tree typ2
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)));
5913 expr
.value
= inside_init
;
5914 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
5915 expr
.original_type
= NULL
;
5916 maybe_warn_string_init (type
, expr
);
5918 if (TYPE_DOMAIN (type
) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
5919 pedwarn_init (init_loc
, OPT_pedantic
,
5920 "initialization of a flexible array member");
5922 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
5923 TYPE_MAIN_VARIANT (type
)))
5928 if (typ2
!= char_type_node
)
5930 error_init ("char-array initialized from wide string");
5931 return error_mark_node
;
5936 if (typ2
== char_type_node
)
5938 error_init ("wide character array initialized from non-wide "
5940 return error_mark_node
;
5942 else if (!comptypes(typ1
, typ2
))
5944 error_init ("wide character array initialized from "
5945 "incompatible wide string");
5946 return error_mark_node
;
5950 TREE_TYPE (inside_init
) = type
;
5951 if (TYPE_DOMAIN (type
) != 0
5952 && TYPE_SIZE (type
) != 0
5953 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
5955 unsigned HOST_WIDE_INT len
= TREE_STRING_LENGTH (inside_init
);
5957 /* Subtract the size of a single (possibly wide) character
5958 because it's ok to ignore the terminating null char
5959 that is counted in the length of the constant. */
5960 if (0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
5962 - (TYPE_PRECISION (typ1
)
5964 pedwarn_init (init_loc
, 0,
5965 ("initializer-string for array of chars "
5967 else if (warn_cxx_compat
5968 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
), len
))
5969 warning_at (init_loc
, OPT_Wc___compat
,
5970 ("initializer-string for array chars "
5971 "is too long for C++"));
5976 else if (INTEGRAL_TYPE_P (typ1
))
5978 error_init ("array of inappropriate type initialized "
5979 "from string constant");
5980 return error_mark_node
;
5984 /* Build a VECTOR_CST from a *constant* vector constructor. If the
5985 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
5986 below and handle as a constructor. */
5987 if (code
== VECTOR_TYPE
5988 && TREE_CODE (TREE_TYPE (inside_init
)) == VECTOR_TYPE
5989 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
, true)
5990 && TREE_CONSTANT (inside_init
))
5992 if (TREE_CODE (inside_init
) == VECTOR_CST
5993 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
5994 TYPE_MAIN_VARIANT (type
)))
5997 if (TREE_CODE (inside_init
) == CONSTRUCTOR
)
5999 unsigned HOST_WIDE_INT ix
;
6001 bool constant_p
= true;
6003 /* Iterate through elements and check if all constructor
6004 elements are *_CSTs. */
6005 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init
), ix
, value
)
6006 if (!CONSTANT_CLASS_P (value
))
6013 return build_vector_from_ctor (type
,
6014 CONSTRUCTOR_ELTS (inside_init
));
6018 if (warn_sequence_point
)
6019 verify_sequence_points (inside_init
);
6021 /* Any type can be initialized
6022 from an expression of the same type, optionally with braces. */
6024 if (inside_init
&& TREE_TYPE (inside_init
) != 0
6025 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
6026 TYPE_MAIN_VARIANT (type
))
6027 || (code
== ARRAY_TYPE
6028 && comptypes (TREE_TYPE (inside_init
), type
))
6029 || (code
== VECTOR_TYPE
6030 && comptypes (TREE_TYPE (inside_init
), type
))
6031 || (code
== POINTER_TYPE
6032 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
6033 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
6034 TREE_TYPE (type
)))))
6036 if (code
== POINTER_TYPE
)
6038 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
6040 if (TREE_CODE (inside_init
) == STRING_CST
6041 || TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6042 inside_init
= array_to_pointer_conversion
6043 (init_loc
, inside_init
);
6046 error_init ("invalid use of non-lvalue array");
6047 return error_mark_node
;
6052 if (code
== VECTOR_TYPE
)
6053 /* Although the types are compatible, we may require a
6055 inside_init
= convert (type
, inside_init
);
6057 if (require_constant
6058 && (code
== VECTOR_TYPE
|| !flag_isoc99
)
6059 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6061 /* As an extension, allow initializing objects with static storage
6062 duration with compound literals (which are then treated just as
6063 the brace enclosed list they contain). Also allow this for
6064 vectors, as we can only assign them with compound literals. */
6065 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
6066 inside_init
= DECL_INITIAL (decl
);
6069 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
6070 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
6072 error_init ("array initialized from non-constant array expression");
6073 return error_mark_node
;
6076 /* Compound expressions can only occur here if -pedantic or
6077 -pedantic-errors is specified. In the later case, we always want
6078 an error. In the former case, we simply want a warning. */
6079 if (require_constant
&& pedantic
6080 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
6083 = valid_compound_expr_initializer (inside_init
,
6084 TREE_TYPE (inside_init
));
6085 if (inside_init
== error_mark_node
)
6086 error_init ("initializer element is not constant");
6088 pedwarn_init (init_loc
, OPT_pedantic
,
6089 "initializer element is not constant");
6090 if (flag_pedantic_errors
)
6091 inside_init
= error_mark_node
;
6093 else if (require_constant
6094 && !initializer_constant_valid_p (inside_init
,
6095 TREE_TYPE (inside_init
)))
6097 error_init ("initializer element is not constant");
6098 inside_init
= error_mark_node
;
6100 else if (require_constant
&& !maybe_const
)
6101 pedwarn_init (init_loc
, 0,
6102 "initializer element is not a constant expression");
6104 /* Added to enable additional -Wmissing-format-attribute warnings. */
6105 if (TREE_CODE (TREE_TYPE (inside_init
)) == POINTER_TYPE
)
6106 inside_init
= convert_for_assignment (init_loc
, type
, inside_init
,
6108 ic_init
, null_pointer_constant
,
6109 NULL_TREE
, NULL_TREE
, 0);
6113 /* Handle scalar types, including conversions. */
6115 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
6116 || code
== POINTER_TYPE
|| code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
6117 || code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
6119 if (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
6120 && (TREE_CODE (init
) == STRING_CST
6121 || TREE_CODE (init
) == COMPOUND_LITERAL_EXPR
))
6122 inside_init
= init
= array_to_pointer_conversion (init_loc
, init
);
6124 inside_init
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
6127 = convert_for_assignment (init_loc
, type
, inside_init
, origtype
,
6128 ic_init
, null_pointer_constant
,
6129 NULL_TREE
, NULL_TREE
, 0);
6131 /* Check to see if we have already given an error message. */
6132 if (inside_init
== error_mark_node
)
6134 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
6136 error_init ("initializer element is not constant");
6137 inside_init
= error_mark_node
;
6139 else if (require_constant
6140 && !initializer_constant_valid_p (inside_init
,
6141 TREE_TYPE (inside_init
)))
6143 error_init ("initializer element is not computable at load time");
6144 inside_init
= error_mark_node
;
6146 else if (require_constant
&& !maybe_const
)
6147 pedwarn_init (init_loc
, 0,
6148 "initializer element is not a constant expression");
6153 /* Come here only for records and arrays. */
6155 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
6157 error_init ("variable-sized object may not be initialized");
6158 return error_mark_node
;
6161 error_init ("invalid initializer");
6162 return error_mark_node
;
6165 /* Handle initializers that use braces. */
6167 /* Type of object we are accumulating a constructor for.
6168 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
6169 static tree constructor_type
;
6171 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
6173 static tree constructor_fields
;
6175 /* For an ARRAY_TYPE, this is the specified index
6176 at which to store the next element we get. */
6177 static tree constructor_index
;
6179 /* For an ARRAY_TYPE, this is the maximum index. */
6180 static tree constructor_max_index
;
6182 /* For a RECORD_TYPE, this is the first field not yet written out. */
6183 static tree constructor_unfilled_fields
;
6185 /* For an ARRAY_TYPE, this is the index of the first element
6186 not yet written out. */
6187 static tree constructor_unfilled_index
;
6189 /* In a RECORD_TYPE, the byte index of the next consecutive field.
6190 This is so we can generate gaps between fields, when appropriate. */
6191 static tree constructor_bit_index
;
6193 /* If we are saving up the elements rather than allocating them,
6194 this is the list of elements so far (in reverse order,
6195 most recent first). */
6196 static VEC(constructor_elt
,gc
) *constructor_elements
;
6198 /* 1 if constructor should be incrementally stored into a constructor chain,
6199 0 if all the elements should be kept in AVL tree. */
6200 static int constructor_incremental
;
6202 /* 1 if so far this constructor's elements are all compile-time constants. */
6203 static int constructor_constant
;
6205 /* 1 if so far this constructor's elements are all valid address constants. */
6206 static int constructor_simple
;
6208 /* 1 if this constructor has an element that cannot be part of a
6209 constant expression. */
6210 static int constructor_nonconst
;
6212 /* 1 if this constructor is erroneous so far. */
6213 static int constructor_erroneous
;
6215 /* Structure for managing pending initializer elements, organized as an
6220 struct init_node
*left
, *right
;
6221 struct init_node
*parent
;
6228 /* Tree of pending elements at this constructor level.
6229 These are elements encountered out of order
6230 which belong at places we haven't reached yet in actually
6232 Will never hold tree nodes across GC runs. */
6233 static struct init_node
*constructor_pending_elts
;
6235 /* The SPELLING_DEPTH of this constructor. */
6236 static int constructor_depth
;
6238 /* DECL node for which an initializer is being read.
6239 0 means we are reading a constructor expression
6240 such as (struct foo) {...}. */
6241 static tree constructor_decl
;
6243 /* Nonzero if this is an initializer for a top-level decl. */
6244 static int constructor_top_level
;
6246 /* Nonzero if there were any member designators in this initializer. */
6247 static int constructor_designated
;
6249 /* Nesting depth of designator list. */
6250 static int designator_depth
;
6252 /* Nonzero if there were diagnosed errors in this designator list. */
6253 static int designator_erroneous
;
6256 /* This stack has a level for each implicit or explicit level of
6257 structuring in the initializer, including the outermost one. It
6258 saves the values of most of the variables above. */
6260 struct constructor_range_stack
;
6262 struct constructor_stack
6264 struct constructor_stack
*next
;
6269 tree unfilled_index
;
6270 tree unfilled_fields
;
6272 VEC(constructor_elt
,gc
) *elements
;
6273 struct init_node
*pending_elts
;
6276 /* If value nonzero, this value should replace the entire
6277 constructor at this level. */
6278 struct c_expr replacement_value
;
6279 struct constructor_range_stack
*range_stack
;
6290 static struct constructor_stack
*constructor_stack
;
6292 /* This stack represents designators from some range designator up to
6293 the last designator in the list. */
6295 struct constructor_range_stack
6297 struct constructor_range_stack
*next
, *prev
;
6298 struct constructor_stack
*stack
;
6305 static struct constructor_range_stack
*constructor_range_stack
;
6307 /* This stack records separate initializers that are nested.
6308 Nested initializers can't happen in ANSI C, but GNU C allows them
6309 in cases like { ... (struct foo) { ... } ... }. */
6311 struct initializer_stack
6313 struct initializer_stack
*next
;
6315 struct constructor_stack
*constructor_stack
;
6316 struct constructor_range_stack
*constructor_range_stack
;
6317 VEC(constructor_elt
,gc
) *elements
;
6318 struct spelling
*spelling
;
6319 struct spelling
*spelling_base
;
6322 char require_constant_value
;
6323 char require_constant_elements
;
6326 static struct initializer_stack
*initializer_stack
;
6328 /* Prepare to parse and output the initializer for variable DECL. */
6331 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
)
6334 struct initializer_stack
*p
= XNEW (struct initializer_stack
);
6336 p
->decl
= constructor_decl
;
6337 p
->require_constant_value
= require_constant_value
;
6338 p
->require_constant_elements
= require_constant_elements
;
6339 p
->constructor_stack
= constructor_stack
;
6340 p
->constructor_range_stack
= constructor_range_stack
;
6341 p
->elements
= constructor_elements
;
6342 p
->spelling
= spelling
;
6343 p
->spelling_base
= spelling_base
;
6344 p
->spelling_size
= spelling_size
;
6345 p
->top_level
= constructor_top_level
;
6346 p
->next
= initializer_stack
;
6347 initializer_stack
= p
;
6349 constructor_decl
= decl
;
6350 constructor_designated
= 0;
6351 constructor_top_level
= top_level
;
6353 if (decl
!= 0 && decl
!= error_mark_node
)
6355 require_constant_value
= TREE_STATIC (decl
);
6356 require_constant_elements
6357 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
6358 /* For a scalar, you can always use any value to initialize,
6359 even within braces. */
6360 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
6361 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6362 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6363 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
6364 locus
= identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)));
6368 require_constant_value
= 0;
6369 require_constant_elements
= 0;
6370 locus
= _("(anonymous)");
6373 constructor_stack
= 0;
6374 constructor_range_stack
= 0;
6376 missing_braces_mentioned
= 0;
6380 RESTORE_SPELLING_DEPTH (0);
6383 push_string (locus
);
6389 struct initializer_stack
*p
= initializer_stack
;
6391 /* Free the whole constructor stack of this initializer. */
6392 while (constructor_stack
)
6394 struct constructor_stack
*q
= constructor_stack
;
6395 constructor_stack
= q
->next
;
6399 gcc_assert (!constructor_range_stack
);
6401 /* Pop back to the data of the outer initializer (if any). */
6402 free (spelling_base
);
6404 constructor_decl
= p
->decl
;
6405 require_constant_value
= p
->require_constant_value
;
6406 require_constant_elements
= p
->require_constant_elements
;
6407 constructor_stack
= p
->constructor_stack
;
6408 constructor_range_stack
= p
->constructor_range_stack
;
6409 constructor_elements
= p
->elements
;
6410 spelling
= p
->spelling
;
6411 spelling_base
= p
->spelling_base
;
6412 spelling_size
= p
->spelling_size
;
6413 constructor_top_level
= p
->top_level
;
6414 initializer_stack
= p
->next
;
6418 /* Call here when we see the initializer is surrounded by braces.
6419 This is instead of a call to push_init_level;
6420 it is matched by a call to pop_init_level.
6422 TYPE is the type to initialize, for a constructor expression.
6423 For an initializer for a decl, TYPE is zero. */
6426 really_start_incremental_init (tree type
)
6428 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
6431 type
= TREE_TYPE (constructor_decl
);
6433 if (TREE_CODE (type
) == VECTOR_TYPE
6434 && TYPE_VECTOR_OPAQUE (type
))
6435 error ("opaque vector types cannot be initialized");
6437 p
->type
= constructor_type
;
6438 p
->fields
= constructor_fields
;
6439 p
->index
= constructor_index
;
6440 p
->max_index
= constructor_max_index
;
6441 p
->unfilled_index
= constructor_unfilled_index
;
6442 p
->unfilled_fields
= constructor_unfilled_fields
;
6443 p
->bit_index
= constructor_bit_index
;
6444 p
->elements
= constructor_elements
;
6445 p
->constant
= constructor_constant
;
6446 p
->simple
= constructor_simple
;
6447 p
->nonconst
= constructor_nonconst
;
6448 p
->erroneous
= constructor_erroneous
;
6449 p
->pending_elts
= constructor_pending_elts
;
6450 p
->depth
= constructor_depth
;
6451 p
->replacement_value
.value
= 0;
6452 p
->replacement_value
.original_code
= ERROR_MARK
;
6453 p
->replacement_value
.original_type
= NULL
;
6457 p
->incremental
= constructor_incremental
;
6458 p
->designated
= constructor_designated
;
6460 constructor_stack
= p
;
6462 constructor_constant
= 1;
6463 constructor_simple
= 1;
6464 constructor_nonconst
= 0;
6465 constructor_depth
= SPELLING_DEPTH ();
6466 constructor_elements
= 0;
6467 constructor_pending_elts
= 0;
6468 constructor_type
= type
;
6469 constructor_incremental
= 1;
6470 constructor_designated
= 0;
6471 designator_depth
= 0;
6472 designator_erroneous
= 0;
6474 if (TREE_CODE (constructor_type
) == RECORD_TYPE
6475 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6477 constructor_fields
= TYPE_FIELDS (constructor_type
);
6478 /* Skip any nameless bit fields at the beginning. */
6479 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
6480 && DECL_NAME (constructor_fields
) == 0)
6481 constructor_fields
= TREE_CHAIN (constructor_fields
);
6483 constructor_unfilled_fields
= constructor_fields
;
6484 constructor_bit_index
= bitsize_zero_node
;
6486 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6488 if (TYPE_DOMAIN (constructor_type
))
6490 constructor_max_index
6491 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
6493 /* Detect non-empty initializations of zero-length arrays. */
6494 if (constructor_max_index
== NULL_TREE
6495 && TYPE_SIZE (constructor_type
))
6496 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6498 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6499 to initialize VLAs will cause a proper error; avoid tree
6500 checking errors as well by setting a safe value. */
6501 if (constructor_max_index
6502 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
6503 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6506 = convert (bitsizetype
,
6507 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
6511 constructor_index
= bitsize_zero_node
;
6512 constructor_max_index
= NULL_TREE
;
6515 constructor_unfilled_index
= constructor_index
;
6517 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6519 /* Vectors are like simple fixed-size arrays. */
6520 constructor_max_index
=
6521 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
6522 constructor_index
= bitsize_zero_node
;
6523 constructor_unfilled_index
= constructor_index
;
6527 /* Handle the case of int x = {5}; */
6528 constructor_fields
= constructor_type
;
6529 constructor_unfilled_fields
= constructor_type
;
6533 /* Push down into a subobject, for initialization.
6534 If this is for an explicit set of braces, IMPLICIT is 0.
6535 If it is because the next element belongs at a lower level,
6536 IMPLICIT is 1 (or 2 if the push is because of designator list). */
6539 push_init_level (int implicit
, struct obstack
* braced_init_obstack
)
6541 struct constructor_stack
*p
;
6542 tree value
= NULL_TREE
;
6544 /* If we've exhausted any levels that didn't have braces,
6545 pop them now. If implicit == 1, this will have been done in
6546 process_init_element; do not repeat it here because in the case
6547 of excess initializers for an empty aggregate this leads to an
6548 infinite cycle of popping a level and immediately recreating
6552 while (constructor_stack
->implicit
)
6554 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6555 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6556 && constructor_fields
== 0)
6557 process_init_element (pop_init_level (1, braced_init_obstack
),
6558 true, braced_init_obstack
);
6559 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
6560 && constructor_max_index
6561 && tree_int_cst_lt (constructor_max_index
,
6563 process_init_element (pop_init_level (1, braced_init_obstack
),
6564 true, braced_init_obstack
);
6570 /* Unless this is an explicit brace, we need to preserve previous
6574 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6575 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6576 && constructor_fields
)
6577 value
= find_init_member (constructor_fields
, braced_init_obstack
);
6578 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6579 value
= find_init_member (constructor_index
, braced_init_obstack
);
6582 p
= XNEW (struct constructor_stack
);
6583 p
->type
= constructor_type
;
6584 p
->fields
= constructor_fields
;
6585 p
->index
= constructor_index
;
6586 p
->max_index
= constructor_max_index
;
6587 p
->unfilled_index
= constructor_unfilled_index
;
6588 p
->unfilled_fields
= constructor_unfilled_fields
;
6589 p
->bit_index
= constructor_bit_index
;
6590 p
->elements
= constructor_elements
;
6591 p
->constant
= constructor_constant
;
6592 p
->simple
= constructor_simple
;
6593 p
->nonconst
= constructor_nonconst
;
6594 p
->erroneous
= constructor_erroneous
;
6595 p
->pending_elts
= constructor_pending_elts
;
6596 p
->depth
= constructor_depth
;
6597 p
->replacement_value
.value
= 0;
6598 p
->replacement_value
.original_code
= ERROR_MARK
;
6599 p
->replacement_value
.original_type
= NULL
;
6600 p
->implicit
= implicit
;
6602 p
->incremental
= constructor_incremental
;
6603 p
->designated
= constructor_designated
;
6604 p
->next
= constructor_stack
;
6606 constructor_stack
= p
;
6608 constructor_constant
= 1;
6609 constructor_simple
= 1;
6610 constructor_nonconst
= 0;
6611 constructor_depth
= SPELLING_DEPTH ();
6612 constructor_elements
= 0;
6613 constructor_incremental
= 1;
6614 constructor_designated
= 0;
6615 constructor_pending_elts
= 0;
6618 p
->range_stack
= constructor_range_stack
;
6619 constructor_range_stack
= 0;
6620 designator_depth
= 0;
6621 designator_erroneous
= 0;
6624 /* Don't die if an entire brace-pair level is superfluous
6625 in the containing level. */
6626 if (constructor_type
== 0)
6628 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
6629 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6631 /* Don't die if there are extra init elts at the end. */
6632 if (constructor_fields
== 0)
6633 constructor_type
= 0;
6636 constructor_type
= TREE_TYPE (constructor_fields
);
6637 push_member_name (constructor_fields
);
6638 constructor_depth
++;
6641 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6643 constructor_type
= TREE_TYPE (constructor_type
);
6644 push_array_bounds (tree_low_cst (constructor_index
, 1));
6645 constructor_depth
++;
6648 if (constructor_type
== 0)
6650 error_init ("extra brace group at end of initializer");
6651 constructor_fields
= 0;
6652 constructor_unfilled_fields
= 0;
6656 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
6658 constructor_constant
= TREE_CONSTANT (value
);
6659 constructor_simple
= TREE_STATIC (value
);
6660 constructor_nonconst
= CONSTRUCTOR_NON_CONST (value
);
6661 constructor_elements
= CONSTRUCTOR_ELTS (value
);
6662 if (!VEC_empty (constructor_elt
, constructor_elements
)
6663 && (TREE_CODE (constructor_type
) == RECORD_TYPE
6664 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
6665 set_nonincremental_init (braced_init_obstack
);
6668 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
6670 missing_braces_mentioned
= 1;
6671 warning_init (OPT_Wmissing_braces
, "missing braces around initializer");
6674 if (TREE_CODE (constructor_type
) == RECORD_TYPE
6675 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6677 constructor_fields
= TYPE_FIELDS (constructor_type
);
6678 /* Skip any nameless bit fields at the beginning. */
6679 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
6680 && DECL_NAME (constructor_fields
) == 0)
6681 constructor_fields
= TREE_CHAIN (constructor_fields
);
6683 constructor_unfilled_fields
= constructor_fields
;
6684 constructor_bit_index
= bitsize_zero_node
;
6686 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6688 /* Vectors are like simple fixed-size arrays. */
6689 constructor_max_index
=
6690 build_int_cst (NULL_TREE
, TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
6691 constructor_index
= convert (bitsizetype
, integer_zero_node
);
6692 constructor_unfilled_index
= constructor_index
;
6694 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6696 if (TYPE_DOMAIN (constructor_type
))
6698 constructor_max_index
6699 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
6701 /* Detect non-empty initializations of zero-length arrays. */
6702 if (constructor_max_index
== NULL_TREE
6703 && TYPE_SIZE (constructor_type
))
6704 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6706 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6707 to initialize VLAs will cause a proper error; avoid tree
6708 checking errors as well by setting a safe value. */
6709 if (constructor_max_index
6710 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
6711 constructor_max_index
= build_int_cst (NULL_TREE
, -1);
6714 = convert (bitsizetype
,
6715 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
6718 constructor_index
= bitsize_zero_node
;
6720 constructor_unfilled_index
= constructor_index
;
6721 if (value
&& TREE_CODE (value
) == STRING_CST
)
6723 /* We need to split the char/wchar array into individual
6724 characters, so that we don't have to special case it
6726 set_nonincremental_init_from_string (value
, braced_init_obstack
);
6731 if (constructor_type
!= error_mark_node
)
6732 warning_init (0, "braces around scalar initializer");
6733 constructor_fields
= constructor_type
;
6734 constructor_unfilled_fields
= constructor_type
;
6738 /* At the end of an implicit or explicit brace level,
6739 finish up that level of constructor. If a single expression
6740 with redundant braces initialized that level, return the
6741 c_expr structure for that expression. Otherwise, the original_code
6742 element is set to ERROR_MARK.
6743 If we were outputting the elements as they are read, return 0 as the value
6744 from inner levels (process_init_element ignores that),
6745 but return error_mark_node as the value from the outermost level
6746 (that's what we want to put in DECL_INITIAL).
6747 Otherwise, return a CONSTRUCTOR expression as the value. */
6750 pop_init_level (int implicit
, struct obstack
* braced_init_obstack
)
6752 struct constructor_stack
*p
;
6755 ret
.original_code
= ERROR_MARK
;
6756 ret
.original_type
= NULL
;
6760 /* When we come to an explicit close brace,
6761 pop any inner levels that didn't have explicit braces. */
6762 while (constructor_stack
->implicit
)
6764 process_init_element (pop_init_level (1, braced_init_obstack
),
6765 true, braced_init_obstack
);
6767 gcc_assert (!constructor_range_stack
);
6770 /* Now output all pending elements. */
6771 constructor_incremental
= 1;
6772 output_pending_init_elements (1, braced_init_obstack
);
6774 p
= constructor_stack
;
6776 /* Error for initializing a flexible array member, or a zero-length
6777 array member in an inappropriate context. */
6778 if (constructor_type
&& constructor_fields
6779 && TREE_CODE (constructor_type
) == ARRAY_TYPE
6780 && TYPE_DOMAIN (constructor_type
)
6781 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
6783 /* Silently discard empty initializations. The parser will
6784 already have pedwarned for empty brackets. */
6785 if (integer_zerop (constructor_unfilled_index
))
6786 constructor_type
= NULL_TREE
;
6789 gcc_assert (!TYPE_SIZE (constructor_type
));
6791 if (constructor_depth
> 2)
6792 error_init ("initialization of flexible array member in a nested context");
6794 pedwarn_init (input_location
, OPT_pedantic
,
6795 "initialization of a flexible array member");
6797 /* We have already issued an error message for the existence
6798 of a flexible array member not at the end of the structure.
6799 Discard the initializer so that we do not die later. */
6800 if (TREE_CHAIN (constructor_fields
) != NULL_TREE
)
6801 constructor_type
= NULL_TREE
;
6805 /* Warn when some struct elements are implicitly initialized to zero. */
6806 if (warn_missing_field_initializers
6808 && TREE_CODE (constructor_type
) == RECORD_TYPE
6809 && constructor_unfilled_fields
)
6811 /* Do not warn for flexible array members or zero-length arrays. */
6812 while (constructor_unfilled_fields
6813 && (!DECL_SIZE (constructor_unfilled_fields
)
6814 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
6815 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
6817 /* Do not warn if this level of the initializer uses member
6818 designators; it is likely to be deliberate. */
6819 if (constructor_unfilled_fields
&& !constructor_designated
)
6821 push_member_name (constructor_unfilled_fields
);
6822 warning_init (OPT_Wmissing_field_initializers
,
6823 "missing initializer");
6824 RESTORE_SPELLING_DEPTH (constructor_depth
);
6828 /* Pad out the end of the structure. */
6829 if (p
->replacement_value
.value
)
6830 /* If this closes a superfluous brace pair,
6831 just pass out the element between them. */
6832 ret
= p
->replacement_value
;
6833 else if (constructor_type
== 0)
6835 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
6836 && TREE_CODE (constructor_type
) != UNION_TYPE
6837 && TREE_CODE (constructor_type
) != ARRAY_TYPE
6838 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
6840 /* A nonincremental scalar initializer--just return
6841 the element, after verifying there is just one. */
6842 if (VEC_empty (constructor_elt
,constructor_elements
))
6844 if (!constructor_erroneous
)
6845 error_init ("empty scalar initializer");
6846 ret
.value
= error_mark_node
;
6848 else if (VEC_length (constructor_elt
,constructor_elements
) != 1)
6850 error_init ("extra elements in scalar initializer");
6851 ret
.value
= VEC_index (constructor_elt
,constructor_elements
,0)->value
;
6854 ret
.value
= VEC_index (constructor_elt
,constructor_elements
,0)->value
;
6858 if (constructor_erroneous
)
6859 ret
.value
= error_mark_node
;
6862 ret
.value
= build_constructor (constructor_type
,
6863 constructor_elements
);
6864 if (constructor_constant
)
6865 TREE_CONSTANT (ret
.value
) = 1;
6866 if (constructor_constant
&& constructor_simple
)
6867 TREE_STATIC (ret
.value
) = 1;
6868 if (constructor_nonconst
)
6869 CONSTRUCTOR_NON_CONST (ret
.value
) = 1;
6873 if (ret
.value
&& TREE_CODE (ret
.value
) != CONSTRUCTOR
)
6875 if (constructor_nonconst
)
6876 ret
.original_code
= C_MAYBE_CONST_EXPR
;
6877 else if (ret
.original_code
== C_MAYBE_CONST_EXPR
)
6878 ret
.original_code
= ERROR_MARK
;
6881 constructor_type
= p
->type
;
6882 constructor_fields
= p
->fields
;
6883 constructor_index
= p
->index
;
6884 constructor_max_index
= p
->max_index
;
6885 constructor_unfilled_index
= p
->unfilled_index
;
6886 constructor_unfilled_fields
= p
->unfilled_fields
;
6887 constructor_bit_index
= p
->bit_index
;
6888 constructor_elements
= p
->elements
;
6889 constructor_constant
= p
->constant
;
6890 constructor_simple
= p
->simple
;
6891 constructor_nonconst
= p
->nonconst
;
6892 constructor_erroneous
= p
->erroneous
;
6893 constructor_incremental
= p
->incremental
;
6894 constructor_designated
= p
->designated
;
6895 constructor_pending_elts
= p
->pending_elts
;
6896 constructor_depth
= p
->depth
;
6898 constructor_range_stack
= p
->range_stack
;
6899 RESTORE_SPELLING_DEPTH (constructor_depth
);
6901 constructor_stack
= p
->next
;
6904 if (ret
.value
== 0 && constructor_stack
== 0)
6905 ret
.value
= error_mark_node
;
6909 /* Common handling for both array range and field name designators.
6910 ARRAY argument is nonzero for array ranges. Returns zero for success. */
6913 set_designator (int array
, struct obstack
* braced_init_obstack
)
6916 enum tree_code subcode
;
6918 /* Don't die if an entire brace-pair level is superfluous
6919 in the containing level. */
6920 if (constructor_type
== 0)
6923 /* If there were errors in this designator list already, bail out
6925 if (designator_erroneous
)
6928 if (!designator_depth
)
6930 gcc_assert (!constructor_range_stack
);
6932 /* Designator list starts at the level of closest explicit
6934 while (constructor_stack
->implicit
)
6936 process_init_element (pop_init_level (1, braced_init_obstack
),
6937 true, braced_init_obstack
);
6939 constructor_designated
= 1;
6943 switch (TREE_CODE (constructor_type
))
6947 subtype
= TREE_TYPE (constructor_fields
);
6948 if (subtype
!= error_mark_node
)
6949 subtype
= TYPE_MAIN_VARIANT (subtype
);
6952 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6958 subcode
= TREE_CODE (subtype
);
6959 if (array
&& subcode
!= ARRAY_TYPE
)
6961 error_init ("array index in non-array initializer");
6964 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
6966 error_init ("field name not in record or union initializer");
6970 constructor_designated
= 1;
6971 push_init_level (2, braced_init_obstack
);
6975 /* If there are range designators in designator list, push a new designator
6976 to constructor_range_stack. RANGE_END is end of such stack range or
6977 NULL_TREE if there is no range designator at this level. */
6980 push_range_stack (tree range_end
, struct obstack
* braced_init_obstack
)
6982 struct constructor_range_stack
*p
;
6984 p
= (struct constructor_range_stack
*)
6985 obstack_alloc (braced_init_obstack
,
6986 sizeof (struct constructor_range_stack
));
6987 p
->prev
= constructor_range_stack
;
6989 p
->fields
= constructor_fields
;
6990 p
->range_start
= constructor_index
;
6991 p
->index
= constructor_index
;
6992 p
->stack
= constructor_stack
;
6993 p
->range_end
= range_end
;
6994 if (constructor_range_stack
)
6995 constructor_range_stack
->next
= p
;
6996 constructor_range_stack
= p
;
6999 /* Within an array initializer, specify the next index to be initialized.
7000 FIRST is that index. If LAST is nonzero, then initialize a range
7001 of indices, running from FIRST through LAST. */
7004 set_init_index (tree first
, tree last
,
7005 struct obstack
* braced_init_obstack
)
7007 if (set_designator (1, braced_init_obstack
))
7010 designator_erroneous
= 1;
7012 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
7013 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
7015 error_init ("array index in initializer not of integer type");
7019 if (TREE_CODE (first
) != INTEGER_CST
)
7021 first
= c_fully_fold (first
, false, NULL
);
7022 if (TREE_CODE (first
) == INTEGER_CST
)
7023 pedwarn_init (input_location
, OPT_pedantic
,
7024 "array index in initializer is not "
7025 "an integer constant expression");
7028 if (last
&& TREE_CODE (last
) != INTEGER_CST
)
7030 last
= c_fully_fold (last
, false, NULL
);
7031 if (TREE_CODE (last
) == INTEGER_CST
)
7032 pedwarn_init (input_location
, OPT_pedantic
,
7033 "array index in initializer is not "
7034 "an integer constant expression");
7037 if (TREE_CODE (first
) != INTEGER_CST
)
7038 error_init ("nonconstant array index in initializer");
7039 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
7040 error_init ("nonconstant array index in initializer");
7041 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
7042 error_init ("array index in non-array initializer");
7043 else if (tree_int_cst_sgn (first
) == -1)
7044 error_init ("array index in initializer exceeds array bounds");
7045 else if (constructor_max_index
7046 && tree_int_cst_lt (constructor_max_index
, first
))
7047 error_init ("array index in initializer exceeds array bounds");
7050 constant_expression_warning (first
);
7052 constant_expression_warning (last
);
7053 constructor_index
= convert (bitsizetype
, first
);
7057 if (tree_int_cst_equal (first
, last
))
7059 else if (tree_int_cst_lt (last
, first
))
7061 error_init ("empty index range in initializer");
7066 last
= convert (bitsizetype
, last
);
7067 if (constructor_max_index
!= 0
7068 && tree_int_cst_lt (constructor_max_index
, last
))
7070 error_init ("array index range in initializer exceeds array bounds");
7077 designator_erroneous
= 0;
7078 if (constructor_range_stack
|| last
)
7079 push_range_stack (last
, braced_init_obstack
);
7083 /* Within a struct initializer, specify the next field to be initialized. */
7086 set_init_label (tree fieldname
, struct obstack
* braced_init_obstack
)
7090 if (set_designator (0, braced_init_obstack
))
7093 designator_erroneous
= 1;
7095 if (TREE_CODE (constructor_type
) != RECORD_TYPE
7096 && TREE_CODE (constructor_type
) != UNION_TYPE
)
7098 error_init ("field name not in record or union initializer");
7102 field
= lookup_field (constructor_type
, fieldname
);
7105 error ("unknown field %qE specified in initializer", fieldname
);
7109 constructor_fields
= TREE_VALUE (field
);
7111 designator_erroneous
= 0;
7112 if (constructor_range_stack
)
7113 push_range_stack (NULL_TREE
, braced_init_obstack
);
7114 field
= TREE_CHAIN (field
);
7117 if (set_designator (0, braced_init_obstack
))
7121 while (field
!= NULL_TREE
);
7124 /* Add a new initializer to the tree of pending initializers. PURPOSE
7125 identifies the initializer, either array index or field in a structure.
7126 VALUE is the value of that index or field. If ORIGTYPE is not
7127 NULL_TREE, it is the original type of VALUE.
7129 IMPLICIT is true if value comes from pop_init_level (1),
7130 the new initializer has been merged with the existing one
7131 and thus no warnings should be emitted about overriding an
7132 existing initializer. */
7135 add_pending_init (tree purpose
, tree value
, tree origtype
, bool implicit
,
7136 struct obstack
* braced_init_obstack
)
7138 struct init_node
*p
, **q
, *r
;
7140 q
= &constructor_pending_elts
;
7143 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7148 if (tree_int_cst_lt (purpose
, p
->purpose
))
7150 else if (tree_int_cst_lt (p
->purpose
, purpose
))
7156 if (TREE_SIDE_EFFECTS (p
->value
))
7157 warning_init (0, "initialized field with side-effects overwritten");
7158 else if (warn_override_init
)
7159 warning_init (OPT_Woverride_init
, "initialized field overwritten");
7162 p
->origtype
= origtype
;
7171 bitpos
= bit_position (purpose
);
7175 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
7177 else if (p
->purpose
!= purpose
)
7183 if (TREE_SIDE_EFFECTS (p
->value
))
7184 warning_init (0, "initialized field with side-effects overwritten");
7185 else if (warn_override_init
)
7186 warning_init (OPT_Woverride_init
, "initialized field overwritten");
7189 p
->origtype
= origtype
;
7195 r
= (struct init_node
*) obstack_alloc (braced_init_obstack
,
7196 sizeof (struct init_node
));
7197 r
->purpose
= purpose
;
7199 r
->origtype
= origtype
;
7209 struct init_node
*s
;
7213 if (p
->balance
== 0)
7215 else if (p
->balance
< 0)
7222 p
->left
->parent
= p
;
7239 constructor_pending_elts
= r
;
7244 struct init_node
*t
= r
->right
;
7248 r
->right
->parent
= r
;
7253 p
->left
->parent
= p
;
7256 p
->balance
= t
->balance
< 0;
7257 r
->balance
= -(t
->balance
> 0);
7272 constructor_pending_elts
= t
;
7278 /* p->balance == +1; growth of left side balances the node. */
7283 else /* r == p->right */
7285 if (p
->balance
== 0)
7286 /* Growth propagation from right side. */
7288 else if (p
->balance
> 0)
7295 p
->right
->parent
= p
;
7312 constructor_pending_elts
= r
;
7314 else /* r->balance == -1 */
7317 struct init_node
*t
= r
->left
;
7321 r
->left
->parent
= r
;
7326 p
->right
->parent
= p
;
7329 r
->balance
= (t
->balance
< 0);
7330 p
->balance
= -(t
->balance
> 0);
7345 constructor_pending_elts
= t
;
7351 /* p->balance == -1; growth of right side balances the node. */
7362 /* Build AVL tree from a sorted chain. */
7365 set_nonincremental_init (struct obstack
* braced_init_obstack
)
7367 unsigned HOST_WIDE_INT ix
;
7370 if (TREE_CODE (constructor_type
) != RECORD_TYPE
7371 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
7374 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements
, ix
, index
, value
)
7376 add_pending_init (index
, value
, NULL_TREE
, false,
7377 braced_init_obstack
);
7379 constructor_elements
= 0;
7380 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7382 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
7383 /* Skip any nameless bit fields at the beginning. */
7384 while (constructor_unfilled_fields
!= 0
7385 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
7386 && DECL_NAME (constructor_unfilled_fields
) == 0)
7387 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
7390 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7392 if (TYPE_DOMAIN (constructor_type
))
7393 constructor_unfilled_index
7394 = convert (bitsizetype
,
7395 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
7397 constructor_unfilled_index
= bitsize_zero_node
;
7399 constructor_incremental
= 0;
7402 /* Build AVL tree from a string constant. */
7405 set_nonincremental_init_from_string (tree str
,
7406 struct obstack
* braced_init_obstack
)
7408 tree value
, purpose
, type
;
7409 HOST_WIDE_INT val
[2];
7410 const char *p
, *end
;
7411 int byte
, wchar_bytes
, charwidth
, bitpos
;
7413 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
7415 wchar_bytes
= TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
))) / BITS_PER_UNIT
;
7416 charwidth
= TYPE_PRECISION (char_type_node
);
7417 type
= TREE_TYPE (constructor_type
);
7418 p
= TREE_STRING_POINTER (str
);
7419 end
= p
+ TREE_STRING_LENGTH (str
);
7421 for (purpose
= bitsize_zero_node
;
7422 p
< end
&& !tree_int_cst_lt (constructor_max_index
, purpose
);
7423 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
7425 if (wchar_bytes
== 1)
7427 val
[1] = (unsigned char) *p
++;
7434 for (byte
= 0; byte
< wchar_bytes
; byte
++)
7436 if (BYTES_BIG_ENDIAN
)
7437 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
7439 bitpos
= byte
* charwidth
;
7440 val
[bitpos
< HOST_BITS_PER_WIDE_INT
]
7441 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
7442 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
7446 if (!TYPE_UNSIGNED (type
))
7448 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
7449 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
7451 if (val
[1] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
7453 val
[1] |= ((HOST_WIDE_INT
) -1) << bitpos
;
7457 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
7462 else if (val
[0] & (((HOST_WIDE_INT
) 1)
7463 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
7464 val
[0] |= ((HOST_WIDE_INT
) -1)
7465 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
7468 value
= build_int_cst_wide (type
, val
[1], val
[0]);
7469 add_pending_init (purpose
, value
, NULL_TREE
, false,
7470 braced_init_obstack
);
7473 constructor_incremental
= 0;
7476 /* Return value of FIELD in pending initializer or zero if the field was
7477 not initialized yet. */
7480 find_init_member (tree field
, struct obstack
* braced_init_obstack
)
7482 struct init_node
*p
;
7484 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7486 if (constructor_incremental
7487 && tree_int_cst_lt (field
, constructor_unfilled_index
))
7488 set_nonincremental_init (braced_init_obstack
);
7490 p
= constructor_pending_elts
;
7493 if (tree_int_cst_lt (field
, p
->purpose
))
7495 else if (tree_int_cst_lt (p
->purpose
, field
))
7501 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7503 tree bitpos
= bit_position (field
);
7505 if (constructor_incremental
7506 && (!constructor_unfilled_fields
7507 || tree_int_cst_lt (bitpos
,
7508 bit_position (constructor_unfilled_fields
))))
7509 set_nonincremental_init (braced_init_obstack
);
7511 p
= constructor_pending_elts
;
7514 if (field
== p
->purpose
)
7516 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
7522 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
7524 if (!VEC_empty (constructor_elt
, constructor_elements
)
7525 && (VEC_last (constructor_elt
, constructor_elements
)->index
7527 return VEC_last (constructor_elt
, constructor_elements
)->value
;
7532 /* "Output" the next constructor element.
7533 At top level, really output it to assembler code now.
7534 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
7535 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
7536 TYPE is the data type that the containing data type wants here.
7537 FIELD is the field (a FIELD_DECL) or the index that this element fills.
7538 If VALUE is a string constant, STRICT_STRING is true if it is
7539 unparenthesized or we should not warn here for it being parenthesized.
7540 For other types of VALUE, STRICT_STRING is not used.
7542 PENDING if non-nil means output pending elements that belong
7543 right after this element. (PENDING is normally 1;
7544 it is 0 while outputting pending elements, to avoid recursion.)
7546 IMPLICIT is true if value comes from pop_init_level (1),
7547 the new initializer has been merged with the existing one
7548 and thus no warnings should be emitted about overriding an
7549 existing initializer. */
7552 output_init_element (tree value
, tree origtype
, bool strict_string
, tree type
,
7553 tree field
, int pending
, bool implicit
,
7554 struct obstack
* braced_init_obstack
)
7556 tree semantic_type
= NULL_TREE
;
7557 constructor_elt
*celt
;
7558 bool maybe_const
= true;
7561 if (type
== error_mark_node
|| value
== error_mark_node
)
7563 constructor_erroneous
= 1;
7566 if (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
7567 && (TREE_CODE (value
) == STRING_CST
7568 || TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
7569 && !(TREE_CODE (value
) == STRING_CST
7570 && TREE_CODE (type
) == ARRAY_TYPE
7571 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
7572 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
7573 TYPE_MAIN_VARIANT (type
)))
7574 value
= array_to_pointer_conversion (input_location
, value
);
7576 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
7577 && require_constant_value
&& !flag_isoc99
&& pending
)
7579 /* As an extension, allow initializing objects with static storage
7580 duration with compound literals (which are then treated just as
7581 the brace enclosed list they contain). */
7582 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
7583 value
= DECL_INITIAL (decl
);
7586 npc
= null_pointer_constant_p (value
);
7587 if (TREE_CODE (value
) == EXCESS_PRECISION_EXPR
)
7589 semantic_type
= TREE_TYPE (value
);
7590 value
= TREE_OPERAND (value
, 0);
7592 value
= c_fully_fold (value
, require_constant_value
, &maybe_const
);
7594 if (value
== error_mark_node
)
7595 constructor_erroneous
= 1;
7596 else if (!TREE_CONSTANT (value
))
7597 constructor_constant
= 0;
7598 else if (!initializer_constant_valid_p (value
, TREE_TYPE (value
))
7599 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
7600 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7601 && DECL_C_BIT_FIELD (field
)
7602 && TREE_CODE (value
) != INTEGER_CST
))
7603 constructor_simple
= 0;
7605 constructor_nonconst
= 1;
7607 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
7609 if (require_constant_value
)
7611 error_init ("initializer element is not constant");
7612 value
= error_mark_node
;
7614 else if (require_constant_elements
)
7615 pedwarn (input_location
, 0,
7616 "initializer element is not computable at load time");
7618 else if (!maybe_const
7619 && (require_constant_value
|| require_constant_elements
))
7620 pedwarn_init (input_location
, 0,
7621 "initializer element is not a constant expression");
7623 /* Issue -Wc++-compat warnings about initializing a bitfield with
7626 && field
!= NULL_TREE
7627 && TREE_CODE (field
) == FIELD_DECL
7628 && DECL_BIT_FIELD_TYPE (field
) != NULL_TREE
7629 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))
7630 != TYPE_MAIN_VARIANT (type
))
7631 && TREE_CODE (DECL_BIT_FIELD_TYPE (field
)) == ENUMERAL_TYPE
)
7633 tree checktype
= origtype
!= NULL_TREE
? origtype
: TREE_TYPE (value
);
7634 if (checktype
!= error_mark_node
7635 && (TYPE_MAIN_VARIANT (checktype
)
7636 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))))
7637 warning_init (OPT_Wc___compat
,
7638 "enum conversion in initialization is invalid in C++");
7641 /* If this field is empty (and not at the end of structure),
7642 don't do anything other than checking the initializer. */
7644 && (TREE_TYPE (field
) == error_mark_node
7645 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
7646 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
7647 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
7648 || TREE_CHAIN (field
)))))
7652 value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, value
);
7653 value
= digest_init (input_location
, type
, value
, origtype
, npc
,
7654 strict_string
, require_constant_value
);
7655 if (value
== error_mark_node
)
7657 constructor_erroneous
= 1;
7660 if (require_constant_value
|| require_constant_elements
)
7661 constant_expression_warning (value
);
7663 /* If this element doesn't come next in sequence,
7664 put it on constructor_pending_elts. */
7665 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
7666 && (!constructor_incremental
7667 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
7669 if (constructor_incremental
7670 && tree_int_cst_lt (field
, constructor_unfilled_index
))
7671 set_nonincremental_init (braced_init_obstack
);
7673 add_pending_init (field
, value
, origtype
, implicit
,
7674 braced_init_obstack
);
7677 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
7678 && (!constructor_incremental
7679 || field
!= constructor_unfilled_fields
))
7681 /* We do this for records but not for unions. In a union,
7682 no matter which field is specified, it can be initialized
7683 right away since it starts at the beginning of the union. */
7684 if (constructor_incremental
)
7686 if (!constructor_unfilled_fields
)
7687 set_nonincremental_init (braced_init_obstack
);
7690 tree bitpos
, unfillpos
;
7692 bitpos
= bit_position (field
);
7693 unfillpos
= bit_position (constructor_unfilled_fields
);
7695 if (tree_int_cst_lt (bitpos
, unfillpos
))
7696 set_nonincremental_init (braced_init_obstack
);
7700 add_pending_init (field
, value
, origtype
, implicit
,
7701 braced_init_obstack
);
7704 else if (TREE_CODE (constructor_type
) == UNION_TYPE
7705 && !VEC_empty (constructor_elt
, constructor_elements
))
7709 if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt
,
7710 constructor_elements
)->value
))
7712 "initialized field with side-effects overwritten");
7713 else if (warn_override_init
)
7714 warning_init (OPT_Woverride_init
, "initialized field overwritten");
7717 /* We can have just one union field set. */
7718 constructor_elements
= 0;
7721 /* Otherwise, output this element either to
7722 constructor_elements or to the assembler file. */
7724 celt
= VEC_safe_push (constructor_elt
, gc
, constructor_elements
, NULL
);
7725 celt
->index
= field
;
7726 celt
->value
= value
;
7728 /* Advance the variable that indicates sequential elements output. */
7729 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7730 constructor_unfilled_index
7731 = size_binop_loc (input_location
, PLUS_EXPR
, constructor_unfilled_index
,
7733 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7735 constructor_unfilled_fields
7736 = TREE_CHAIN (constructor_unfilled_fields
);
7738 /* Skip any nameless bit fields. */
7739 while (constructor_unfilled_fields
!= 0
7740 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
7741 && DECL_NAME (constructor_unfilled_fields
) == 0)
7742 constructor_unfilled_fields
=
7743 TREE_CHAIN (constructor_unfilled_fields
);
7745 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
7746 constructor_unfilled_fields
= 0;
7748 /* Now output any pending elements which have become next. */
7750 output_pending_init_elements (0, braced_init_obstack
);
7753 /* Output any pending elements which have become next.
7754 As we output elements, constructor_unfilled_{fields,index}
7755 advances, which may cause other elements to become next;
7756 if so, they too are output.
7758 If ALL is 0, we return when there are
7759 no more pending elements to output now.
7761 If ALL is 1, we output space as necessary so that
7762 we can output all the pending elements. */
7764 output_pending_init_elements (int all
, struct obstack
* braced_init_obstack
)
7766 struct init_node
*elt
= constructor_pending_elts
;
7771 /* Look through the whole pending tree.
7772 If we find an element that should be output now,
7773 output it. Otherwise, set NEXT to the element
7774 that comes first among those still pending. */
7779 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7781 if (tree_int_cst_equal (elt
->purpose
,
7782 constructor_unfilled_index
))
7783 output_init_element (elt
->value
, elt
->origtype
, true,
7784 TREE_TYPE (constructor_type
),
7785 constructor_unfilled_index
, 0, false,
7786 braced_init_obstack
);
7787 else if (tree_int_cst_lt (constructor_unfilled_index
,
7790 /* Advance to the next smaller node. */
7795 /* We have reached the smallest node bigger than the
7796 current unfilled index. Fill the space first. */
7797 next
= elt
->purpose
;
7803 /* Advance to the next bigger node. */
7808 /* We have reached the biggest node in a subtree. Find
7809 the parent of it, which is the next bigger node. */
7810 while (elt
->parent
&& elt
->parent
->right
== elt
)
7813 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
7816 next
= elt
->purpose
;
7822 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
7823 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7825 tree ctor_unfilled_bitpos
, elt_bitpos
;
7827 /* If the current record is complete we are done. */
7828 if (constructor_unfilled_fields
== 0)
7831 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
7832 elt_bitpos
= bit_position (elt
->purpose
);
7833 /* We can't compare fields here because there might be empty
7834 fields in between. */
7835 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
7837 constructor_unfilled_fields
= elt
->purpose
;
7838 output_init_element (elt
->value
, elt
->origtype
, true,
7839 TREE_TYPE (elt
->purpose
),
7840 elt
->purpose
, 0, false,
7841 braced_init_obstack
);
7843 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
7845 /* Advance to the next smaller node. */
7850 /* We have reached the smallest node bigger than the
7851 current unfilled field. Fill the space first. */
7852 next
= elt
->purpose
;
7858 /* Advance to the next bigger node. */
7863 /* We have reached the biggest node in a subtree. Find
7864 the parent of it, which is the next bigger node. */
7865 while (elt
->parent
&& elt
->parent
->right
== elt
)
7869 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
7870 bit_position (elt
->purpose
))))
7872 next
= elt
->purpose
;
7880 /* Ordinarily return, but not if we want to output all
7881 and there are elements left. */
7882 if (!(all
&& next
!= 0))
7885 /* If it's not incremental, just skip over the gap, so that after
7886 jumping to retry we will output the next successive element. */
7887 if (TREE_CODE (constructor_type
) == RECORD_TYPE
7888 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7889 constructor_unfilled_fields
= next
;
7890 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7891 constructor_unfilled_index
= next
;
7893 /* ELT now points to the node in the pending tree with the next
7894 initializer to output. */
7898 /* Add one non-braced element to the current constructor level.
7899 This adjusts the current position within the constructor's type.
7900 This may also start or terminate implicit levels
7901 to handle a partly-braced initializer.
7903 Once this has found the correct level for the new element,
7904 it calls output_init_element.
7906 IMPLICIT is true if value comes from pop_init_level (1),
7907 the new initializer has been merged with the existing one
7908 and thus no warnings should be emitted about overriding an
7909 existing initializer. */
7912 process_init_element (struct c_expr value
, bool implicit
,
7913 struct obstack
* braced_init_obstack
)
7915 tree orig_value
= value
.value
;
7916 int string_flag
= orig_value
!= 0 && TREE_CODE (orig_value
) == STRING_CST
;
7917 bool strict_string
= value
.original_code
== STRING_CST
;
7919 designator_depth
= 0;
7920 designator_erroneous
= 0;
7922 /* Handle superfluous braces around string cst as in
7923 char x[] = {"foo"}; */
7926 && TREE_CODE (constructor_type
) == ARRAY_TYPE
7927 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
7928 && integer_zerop (constructor_unfilled_index
))
7930 if (constructor_stack
->replacement_value
.value
)
7931 error_init ("excess elements in char array initializer");
7932 constructor_stack
->replacement_value
= value
;
7936 if (constructor_stack
->replacement_value
.value
!= 0)
7938 error_init ("excess elements in struct initializer");
7942 /* Ignore elements of a brace group if it is entirely superfluous
7943 and has already been diagnosed. */
7944 if (constructor_type
== 0)
7947 /* If we've exhausted any levels that didn't have braces,
7949 while (constructor_stack
->implicit
)
7951 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
7952 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7953 && constructor_fields
== 0)
7954 process_init_element (pop_init_level (1, braced_init_obstack
),
7955 true, braced_init_obstack
);
7956 else if ((TREE_CODE (constructor_type
) == ARRAY_TYPE
7957 || TREE_CODE (constructor_type
) == VECTOR_TYPE
)
7958 && (constructor_max_index
== 0
7959 || tree_int_cst_lt (constructor_max_index
,
7960 constructor_index
)))
7961 process_init_element (pop_init_level (1, braced_init_obstack
),
7962 true, braced_init_obstack
);
7967 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
7968 if (constructor_range_stack
)
7970 /* If value is a compound literal and we'll be just using its
7971 content, don't put it into a SAVE_EXPR. */
7972 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
7973 || !require_constant_value
7976 tree semantic_type
= NULL_TREE
;
7977 if (TREE_CODE (value
.value
) == EXCESS_PRECISION_EXPR
)
7979 semantic_type
= TREE_TYPE (value
.value
);
7980 value
.value
= TREE_OPERAND (value
.value
, 0);
7982 value
.value
= c_save_expr (value
.value
);
7984 value
.value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
7991 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
7994 enum tree_code fieldcode
;
7996 if (constructor_fields
== 0)
7998 pedwarn_init (input_location
, 0,
7999 "excess elements in struct initializer");
8003 fieldtype
= TREE_TYPE (constructor_fields
);
8004 if (fieldtype
!= error_mark_node
)
8005 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
8006 fieldcode
= TREE_CODE (fieldtype
);
8008 /* Error for non-static initialization of a flexible array member. */
8009 if (fieldcode
== ARRAY_TYPE
8010 && !require_constant_value
8011 && TYPE_SIZE (fieldtype
) == NULL_TREE
8012 && TREE_CHAIN (constructor_fields
) == NULL_TREE
)
8014 error_init ("non-static initialization of a flexible array member");
8018 /* Accept a string constant to initialize a subarray. */
8019 if (value
.value
!= 0
8020 && fieldcode
== ARRAY_TYPE
8021 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
8023 value
.value
= orig_value
;
8024 /* Otherwise, if we have come to a subaggregate,
8025 and we don't have an element of its type, push into it. */
8026 else if (value
.value
!= 0
8027 && value
.value
!= error_mark_node
8028 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
8029 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
8030 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
8032 push_init_level (1, braced_init_obstack
);
8038 push_member_name (constructor_fields
);
8039 output_init_element (value
.value
, value
.original_type
,
8040 strict_string
, fieldtype
,
8041 constructor_fields
, 1, implicit
,
8042 braced_init_obstack
);
8043 RESTORE_SPELLING_DEPTH (constructor_depth
);
8046 /* Do the bookkeeping for an element that was
8047 directly output as a constructor. */
8049 /* For a record, keep track of end position of last field. */
8050 if (DECL_SIZE (constructor_fields
))
8051 constructor_bit_index
8052 = size_binop_loc (input_location
, PLUS_EXPR
,
8053 bit_position (constructor_fields
),
8054 DECL_SIZE (constructor_fields
));
8056 /* If the current field was the first one not yet written out,
8057 it isn't now, so update. */
8058 if (constructor_unfilled_fields
== constructor_fields
)
8060 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
8061 /* Skip any nameless bit fields. */
8062 while (constructor_unfilled_fields
!= 0
8063 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
8064 && DECL_NAME (constructor_unfilled_fields
) == 0)
8065 constructor_unfilled_fields
=
8066 TREE_CHAIN (constructor_unfilled_fields
);
8070 constructor_fields
= TREE_CHAIN (constructor_fields
);
8071 /* Skip any nameless bit fields at the beginning. */
8072 while (constructor_fields
!= 0
8073 && DECL_C_BIT_FIELD (constructor_fields
)
8074 && DECL_NAME (constructor_fields
) == 0)
8075 constructor_fields
= TREE_CHAIN (constructor_fields
);
8077 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
8080 enum tree_code fieldcode
;
8082 if (constructor_fields
== 0)
8084 pedwarn_init (input_location
, 0,
8085 "excess elements in union initializer");
8089 fieldtype
= TREE_TYPE (constructor_fields
);
8090 if (fieldtype
!= error_mark_node
)
8091 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
8092 fieldcode
= TREE_CODE (fieldtype
);
8094 /* Warn that traditional C rejects initialization of unions.
8095 We skip the warning if the value is zero. This is done
8096 under the assumption that the zero initializer in user
8097 code appears conditioned on e.g. __STDC__ to avoid
8098 "missing initializer" warnings and relies on default
8099 initialization to zero in the traditional C case.
8100 We also skip the warning if the initializer is designated,
8101 again on the assumption that this must be conditional on
8102 __STDC__ anyway (and we've already complained about the
8103 member-designator already). */
8104 if (!in_system_header
&& !constructor_designated
8105 && !(value
.value
&& (integer_zerop (value
.value
)
8106 || real_zerop (value
.value
))))
8107 warning (OPT_Wtraditional
, "traditional C rejects initialization "
8110 /* Accept a string constant to initialize a subarray. */
8111 if (value
.value
!= 0
8112 && fieldcode
== ARRAY_TYPE
8113 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
8115 value
.value
= orig_value
;
8116 /* Otherwise, if we have come to a subaggregate,
8117 and we don't have an element of its type, push into it. */
8118 else if (value
.value
!= 0
8119 && value
.value
!= error_mark_node
8120 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
8121 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
8122 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
8124 push_init_level (1, braced_init_obstack
);
8130 push_member_name (constructor_fields
);
8131 output_init_element (value
.value
, value
.original_type
,
8132 strict_string
, fieldtype
,
8133 constructor_fields
, 1, implicit
,
8134 braced_init_obstack
);
8135 RESTORE_SPELLING_DEPTH (constructor_depth
);
8138 /* Do the bookkeeping for an element that was
8139 directly output as a constructor. */
8141 constructor_bit_index
= DECL_SIZE (constructor_fields
);
8142 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
8145 constructor_fields
= 0;
8147 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8149 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8150 enum tree_code eltcode
= TREE_CODE (elttype
);
8152 /* Accept a string constant to initialize a subarray. */
8153 if (value
.value
!= 0
8154 && eltcode
== ARRAY_TYPE
8155 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
8157 value
.value
= orig_value
;
8158 /* Otherwise, if we have come to a subaggregate,
8159 and we don't have an element of its type, push into it. */
8160 else if (value
.value
!= 0
8161 && value
.value
!= error_mark_node
8162 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
8163 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
8164 || eltcode
== UNION_TYPE
|| eltcode
== VECTOR_TYPE
))
8166 push_init_level (1, braced_init_obstack
);
8170 if (constructor_max_index
!= 0
8171 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
8172 || integer_all_onesp (constructor_max_index
)))
8174 pedwarn_init (input_location
, 0,
8175 "excess elements in array initializer");
8179 /* Now output the actual element. */
8182 push_array_bounds (tree_low_cst (constructor_index
, 1));
8183 output_init_element (value
.value
, value
.original_type
,
8184 strict_string
, elttype
,
8185 constructor_index
, 1, implicit
,
8186 braced_init_obstack
);
8187 RESTORE_SPELLING_DEPTH (constructor_depth
);
8191 = size_binop_loc (input_location
, PLUS_EXPR
,
8192 constructor_index
, bitsize_one_node
);
8195 /* If we are doing the bookkeeping for an element that was
8196 directly output as a constructor, we must update
8197 constructor_unfilled_index. */
8198 constructor_unfilled_index
= constructor_index
;
8200 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
8202 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8204 /* Do a basic check of initializer size. Note that vectors
8205 always have a fixed size derived from their type. */
8206 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
8208 pedwarn_init (input_location
, 0,
8209 "excess elements in vector initializer");
8213 /* Now output the actual element. */
8216 if (TREE_CODE (value
.value
) == VECTOR_CST
)
8217 elttype
= TYPE_MAIN_VARIANT (constructor_type
);
8218 output_init_element (value
.value
, value
.original_type
,
8219 strict_string
, elttype
,
8220 constructor_index
, 1, implicit
,
8221 braced_init_obstack
);
8225 = size_binop_loc (input_location
,
8226 PLUS_EXPR
, constructor_index
, bitsize_one_node
);
8229 /* If we are doing the bookkeeping for an element that was
8230 directly output as a constructor, we must update
8231 constructor_unfilled_index. */
8232 constructor_unfilled_index
= constructor_index
;
8235 /* Handle the sole element allowed in a braced initializer
8236 for a scalar variable. */
8237 else if (constructor_type
!= error_mark_node
8238 && constructor_fields
== 0)
8240 pedwarn_init (input_location
, 0,
8241 "excess elements in scalar initializer");
8247 output_init_element (value
.value
, value
.original_type
,
8248 strict_string
, constructor_type
,
8249 NULL_TREE
, 1, implicit
,
8250 braced_init_obstack
);
8251 constructor_fields
= 0;
8254 /* Handle range initializers either at this level or anywhere higher
8255 in the designator stack. */
8256 if (constructor_range_stack
)
8258 struct constructor_range_stack
*p
, *range_stack
;
8261 range_stack
= constructor_range_stack
;
8262 constructor_range_stack
= 0;
8263 while (constructor_stack
!= range_stack
->stack
)
8265 gcc_assert (constructor_stack
->implicit
);
8266 process_init_element (pop_init_level (1,
8267 braced_init_obstack
),
8268 true, braced_init_obstack
);
8270 for (p
= range_stack
;
8271 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
8274 gcc_assert (constructor_stack
->implicit
);
8275 process_init_element (pop_init_level (1, braced_init_obstack
),
8276 true, braced_init_obstack
);
8279 p
->index
= size_binop_loc (input_location
,
8280 PLUS_EXPR
, p
->index
, bitsize_one_node
);
8281 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
8286 constructor_index
= p
->index
;
8287 constructor_fields
= p
->fields
;
8288 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
8296 push_init_level (2, braced_init_obstack
);
8297 p
->stack
= constructor_stack
;
8298 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
8299 p
->index
= p
->range_start
;
8303 constructor_range_stack
= range_stack
;
8310 constructor_range_stack
= 0;
8313 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
8314 (guaranteed to be 'volatile' or null) and ARGS (represented using
8315 an ASM_EXPR node). */
8317 build_asm_stmt (tree cv_qualifier
, tree args
)
8319 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
8320 ASM_VOLATILE_P (args
) = 1;
8321 return add_stmt (args
);
8324 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
8325 some INPUTS, and some CLOBBERS. The latter three may be NULL.
8326 SIMPLE indicates whether there was anything at all after the
8327 string in the asm expression -- asm("blah") and asm("blah" : )
8328 are subtly different. We use a ASM_EXPR node to represent this. */
8330 build_asm_expr (location_t loc
, tree string
, tree outputs
, tree inputs
,
8331 tree clobbers
, tree labels
, bool simple
)
8336 const char *constraint
;
8337 const char **oconstraints
;
8338 bool allows_mem
, allows_reg
, is_inout
;
8339 int ninputs
, noutputs
;
8341 ninputs
= list_length (inputs
);
8342 noutputs
= list_length (outputs
);
8343 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
8345 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
8347 /* Remove output conversions that change the type but not the mode. */
8348 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
8350 tree output
= TREE_VALUE (tail
);
8352 /* ??? Really, this should not be here. Users should be using a
8353 proper lvalue, dammit. But there's a long history of using casts
8354 in the output operands. In cases like longlong.h, this becomes a
8355 primitive form of typechecking -- if the cast can be removed, then
8356 the output operand had a type of the proper width; otherwise we'll
8357 get an error. Gross, but ... */
8358 STRIP_NOPS (output
);
8360 if (!lvalue_or_else (output
, lv_asm
))
8361 output
= error_mark_node
;
8363 if (output
!= error_mark_node
8364 && (TREE_READONLY (output
)
8365 || TYPE_READONLY (TREE_TYPE (output
))
8366 || ((TREE_CODE (TREE_TYPE (output
)) == RECORD_TYPE
8367 || TREE_CODE (TREE_TYPE (output
)) == UNION_TYPE
)
8368 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output
)))))
8369 readonly_error (output
, lv_asm
);
8371 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
8372 oconstraints
[i
] = constraint
;
8374 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
8375 &allows_mem
, &allows_reg
, &is_inout
))
8377 /* If the operand is going to end up in memory,
8378 mark it addressable. */
8379 if (!allows_reg
&& !c_mark_addressable (output
))
8380 output
= error_mark_node
;
8383 output
= error_mark_node
;
8385 TREE_VALUE (tail
) = output
;
8388 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
8392 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
8393 input
= TREE_VALUE (tail
);
8395 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
8396 oconstraints
, &allows_mem
, &allows_reg
))
8398 /* If the operand is going to end up in memory,
8399 mark it addressable. */
8400 if (!allows_reg
&& allows_mem
)
8402 /* Strip the nops as we allow this case. FIXME, this really
8403 should be rejected or made deprecated. */
8405 if (!c_mark_addressable (input
))
8406 input
= error_mark_node
;
8410 input
= error_mark_node
;
8412 TREE_VALUE (tail
) = input
;
8415 /* ASMs with labels cannot have outputs. This should have been
8416 enforced by the parser. */
8417 gcc_assert (outputs
== NULL
|| labels
== NULL
);
8419 args
= build_stmt (loc
, ASM_EXPR
, string
, outputs
, inputs
, clobbers
, labels
);
8421 /* asm statements without outputs, including simple ones, are treated
8423 ASM_INPUT_P (args
) = simple
;
8424 ASM_VOLATILE_P (args
) = (noutputs
== 0);
8429 /* Generate a goto statement to LABEL. LOC is the location of the
8433 c_finish_goto_label (location_t loc
, tree label
)
8435 tree decl
= lookup_label_for_goto (loc
, label
);
8438 TREE_USED (decl
) = 1;
8440 tree t
= build1 (GOTO_EXPR
, void_type_node
, decl
);
8441 SET_EXPR_LOCATION (t
, loc
);
8442 return add_stmt (t
);
8446 /* Generate a computed goto statement to EXPR. LOC is the location of
8450 c_finish_goto_ptr (location_t loc
, tree expr
)
8453 pedwarn (loc
, OPT_pedantic
, "ISO C forbids %<goto *expr;%>");
8454 expr
= c_fully_fold (expr
, false, NULL
);
8455 expr
= convert (ptr_type_node
, expr
);
8456 t
= build1 (GOTO_EXPR
, void_type_node
, expr
);
8457 SET_EXPR_LOCATION (t
, loc
);
8458 return add_stmt (t
);
8461 /* Generate a C `return' statement. RETVAL is the expression for what
8462 to return, or a null pointer for `return;' with no value. LOC is
8463 the location of the return statement. If ORIGTYPE is not NULL_TREE, it
8464 is the original type of RETVAL. */
8467 c_finish_return (location_t loc
, tree retval
, tree origtype
)
8469 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
)), ret_stmt
;
8470 bool no_warning
= false;
8473 if (TREE_THIS_VOLATILE (current_function_decl
))
8475 "function declared %<noreturn%> has a %<return%> statement");
8479 tree semantic_type
= NULL_TREE
;
8480 npc
= null_pointer_constant_p (retval
);
8481 if (TREE_CODE (retval
) == EXCESS_PRECISION_EXPR
)
8483 semantic_type
= TREE_TYPE (retval
);
8484 retval
= TREE_OPERAND (retval
, 0);
8486 retval
= c_fully_fold (retval
, false, NULL
);
8488 retval
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, retval
);
8493 current_function_returns_null
= 1;
8494 if ((warn_return_type
|| flag_isoc99
)
8495 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
8497 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wreturn_type
,
8498 "%<return%> with no value, in "
8499 "function returning non-void");
8503 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
8505 current_function_returns_null
= 1;
8506 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
8508 "%<return%> with a value, in function returning void");
8510 pedwarn (loc
, OPT_pedantic
, "ISO C forbids "
8511 "%<return%> with expression, in function returning void");
8515 tree t
= convert_for_assignment (loc
, valtype
, retval
, origtype
,
8517 npc
, NULL_TREE
, NULL_TREE
, 0);
8518 tree res
= DECL_RESULT (current_function_decl
);
8521 current_function_returns_value
= 1;
8522 if (t
== error_mark_node
)
8525 inner
= t
= convert (TREE_TYPE (res
), t
);
8527 /* Strip any conversions, additions, and subtractions, and see if
8528 we are returning the address of a local variable. Warn if so. */
8531 switch (TREE_CODE (inner
))
8534 case NON_LVALUE_EXPR
:
8536 case POINTER_PLUS_EXPR
:
8537 inner
= TREE_OPERAND (inner
, 0);
8541 /* If the second operand of the MINUS_EXPR has a pointer
8542 type (or is converted from it), this may be valid, so
8543 don't give a warning. */
8545 tree op1
= TREE_OPERAND (inner
, 1);
8547 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
8548 && (CONVERT_EXPR_P (op1
)
8549 || TREE_CODE (op1
) == NON_LVALUE_EXPR
))
8550 op1
= TREE_OPERAND (op1
, 0);
8552 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
8555 inner
= TREE_OPERAND (inner
, 0);
8560 inner
= TREE_OPERAND (inner
, 0);
8562 while (REFERENCE_CLASS_P (inner
)
8563 && TREE_CODE (inner
) != INDIRECT_REF
)
8564 inner
= TREE_OPERAND (inner
, 0);
8567 && !DECL_EXTERNAL (inner
)
8568 && !TREE_STATIC (inner
)
8569 && DECL_CONTEXT (inner
) == current_function_decl
)
8571 0, "function returns address of local variable");
8581 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
8582 SET_EXPR_LOCATION (retval
, loc
);
8584 if (warn_sequence_point
)
8585 verify_sequence_points (retval
);
8588 ret_stmt
= build_stmt (loc
, RETURN_EXPR
, retval
);
8589 TREE_NO_WARNING (ret_stmt
) |= no_warning
;
8590 return add_stmt (ret_stmt
);
8594 /* The SWITCH_EXPR being built. */
8597 /* The original type of the testing expression, i.e. before the
8598 default conversion is applied. */
8601 /* A splay-tree mapping the low element of a case range to the high
8602 element, or NULL_TREE if there is no high element. Used to
8603 determine whether or not a new case label duplicates an old case
8604 label. We need a tree, rather than simply a hash table, because
8605 of the GNU case range extension. */
8608 /* The bindings at the point of the switch. This is used for
8609 warnings crossing decls when branching to a case label. */
8610 struct c_spot_bindings
*bindings
;
8612 /* The next node on the stack. */
8613 struct c_switch
*next
;
8616 /* A stack of the currently active switch statements. The innermost
8617 switch statement is on the top of the stack. There is no need to
8618 mark the stack for garbage collection because it is only active
8619 during the processing of the body of a function, and we never
8620 collect at that point. */
8622 struct c_switch
*c_switch_stack
;
8624 /* Start a C switch statement, testing expression EXP. Return the new
8625 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
8626 SWITCH_COND_LOC is the location of the switch's condition. */
8629 c_start_case (location_t switch_loc
,
8630 location_t switch_cond_loc
,
8633 tree orig_type
= error_mark_node
;
8634 struct c_switch
*cs
;
8636 if (exp
!= error_mark_node
)
8638 orig_type
= TREE_TYPE (exp
);
8640 if (!INTEGRAL_TYPE_P (orig_type
))
8642 if (orig_type
!= error_mark_node
)
8644 error_at (switch_cond_loc
, "switch quantity not an integer");
8645 orig_type
= error_mark_node
;
8647 exp
= integer_zero_node
;
8651 tree type
= TYPE_MAIN_VARIANT (orig_type
);
8653 if (!in_system_header
8654 && (type
== long_integer_type_node
8655 || type
== long_unsigned_type_node
))
8656 warning_at (switch_cond_loc
,
8657 OPT_Wtraditional
, "%<long%> switch expression not "
8658 "converted to %<int%> in ISO C");
8660 exp
= c_fully_fold (exp
, false, NULL
);
8661 exp
= default_conversion (exp
);
8663 if (warn_sequence_point
)
8664 verify_sequence_points (exp
);
8668 /* Add this new SWITCH_EXPR to the stack. */
8669 cs
= XNEW (struct c_switch
);
8670 cs
->switch_expr
= build3 (SWITCH_EXPR
, orig_type
, exp
, NULL_TREE
, NULL_TREE
);
8671 SET_EXPR_LOCATION (cs
->switch_expr
, switch_loc
);
8672 cs
->orig_type
= orig_type
;
8673 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
8674 cs
->bindings
= c_get_switch_bindings ();
8675 cs
->next
= c_switch_stack
;
8676 c_switch_stack
= cs
;
8678 return add_stmt (cs
->switch_expr
);
8681 /* Process a case label at location LOC. */
8684 do_case (location_t loc
, tree low_value
, tree high_value
)
8686 tree label
= NULL_TREE
;
8688 if (low_value
&& TREE_CODE (low_value
) != INTEGER_CST
)
8690 low_value
= c_fully_fold (low_value
, false, NULL
);
8691 if (TREE_CODE (low_value
) == INTEGER_CST
)
8692 pedwarn (input_location
, OPT_pedantic
,
8693 "case label is not an integer constant expression");
8696 if (high_value
&& TREE_CODE (high_value
) != INTEGER_CST
)
8698 high_value
= c_fully_fold (high_value
, false, NULL
);
8699 if (TREE_CODE (high_value
) == INTEGER_CST
)
8700 pedwarn (input_location
, OPT_pedantic
,
8701 "case label is not an integer constant expression");
8704 if (c_switch_stack
== NULL
)
8707 error_at (loc
, "case label not within a switch statement");
8709 error_at (loc
, "%<default%> label not within a switch statement");
8713 if (c_check_switch_jump_warnings (c_switch_stack
->bindings
,
8714 EXPR_LOCATION (c_switch_stack
->switch_expr
),
8718 label
= c_add_case_label (loc
, c_switch_stack
->cases
,
8719 SWITCH_COND (c_switch_stack
->switch_expr
),
8720 c_switch_stack
->orig_type
,
8721 low_value
, high_value
);
8722 if (label
== error_mark_node
)
8727 /* Finish the switch statement. */
8730 c_finish_case (tree body
)
8732 struct c_switch
*cs
= c_switch_stack
;
8733 location_t switch_location
;
8735 SWITCH_BODY (cs
->switch_expr
) = body
;
8737 /* Emit warnings as needed. */
8738 switch_location
= EXPR_LOCATION (cs
->switch_expr
);
8739 c_do_switch_warnings (cs
->cases
, switch_location
,
8740 TREE_TYPE (cs
->switch_expr
),
8741 SWITCH_COND (cs
->switch_expr
));
8743 /* Pop the stack. */
8744 c_switch_stack
= cs
->next
;
8745 splay_tree_delete (cs
->cases
);
8746 c_release_switch_bindings (cs
->bindings
);
8750 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
8751 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8752 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
8753 statement, and was not surrounded with parenthesis. */
8756 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
8757 tree else_block
, bool nested_if
)
8761 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
8762 if (warn_parentheses
&& nested_if
&& else_block
== NULL
)
8764 tree inner_if
= then_block
;
8766 /* We know from the grammar productions that there is an IF nested
8767 within THEN_BLOCK. Due to labels and c99 conditional declarations,
8768 it might not be exactly THEN_BLOCK, but should be the last
8769 non-container statement within. */
8771 switch (TREE_CODE (inner_if
))
8776 inner_if
= BIND_EXPR_BODY (inner_if
);
8778 case STATEMENT_LIST
:
8779 inner_if
= expr_last (then_block
);
8781 case TRY_FINALLY_EXPR
:
8782 case TRY_CATCH_EXPR
:
8783 inner_if
= TREE_OPERAND (inner_if
, 0);
8790 if (COND_EXPR_ELSE (inner_if
))
8791 warning_at (if_locus
, OPT_Wparentheses
,
8792 "suggest explicit braces to avoid ambiguous %<else%>");
8795 stmt
= build3 (COND_EXPR
, void_type_node
, cond
, then_block
, else_block
);
8796 SET_EXPR_LOCATION (stmt
, if_locus
);
8800 /* Emit a general-purpose loop construct. START_LOCUS is the location of
8801 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
8802 is false for DO loops. INCR is the FOR increment expression. BODY is
8803 the statement controlled by the loop. BLAB is the break label. CLAB is
8804 the continue label. Everything is allowed to be NULL. */
8807 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
8808 tree blab
, tree clab
, bool cond_is_first
)
8810 tree entry
= NULL
, exit
= NULL
, t
;
8812 /* If the condition is zero don't generate a loop construct. */
8813 if (cond
&& integer_zerop (cond
))
8817 t
= build_and_jump (&blab
);
8818 SET_EXPR_LOCATION (t
, start_locus
);
8824 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
8826 /* If we have an exit condition, then we build an IF with gotos either
8827 out of the loop, or to the top of it. If there's no exit condition,
8828 then we just build a jump back to the top. */
8829 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
8831 if (cond
&& !integer_nonzerop (cond
))
8833 /* Canonicalize the loop condition to the end. This means
8834 generating a branch to the loop condition. Reuse the
8835 continue label, if possible. */
8840 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
8841 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
8844 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
8845 SET_EXPR_LOCATION (t
, start_locus
);
8849 t
= build_and_jump (&blab
);
8851 exit
= fold_build3_loc (start_locus
,
8852 COND_EXPR
, void_type_node
, cond
, exit
, t
);
8854 exit
= fold_build3_loc (input_location
,
8855 COND_EXPR
, void_type_node
, cond
, exit
, t
);
8864 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
8872 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
8876 c_finish_bc_stmt (location_t loc
, tree
*label_p
, bool is_break
)
8879 tree label
= *label_p
;
8881 /* In switch statements break is sometimes stylistically used after
8882 a return statement. This can lead to spurious warnings about
8883 control reaching the end of a non-void function when it is
8884 inlined. Note that we are calling block_may_fallthru with
8885 language specific tree nodes; this works because
8886 block_may_fallthru returns true when given something it does not
8888 skip
= !block_may_fallthru (cur_stmt_list
);
8893 *label_p
= label
= create_artificial_label (loc
);
8895 else if (TREE_CODE (label
) == LABEL_DECL
)
8897 else switch (TREE_INT_CST_LOW (label
))
8901 error_at (loc
, "break statement not within loop or switch");
8903 error_at (loc
, "continue statement not within a loop");
8907 gcc_assert (is_break
);
8908 error_at (loc
, "break statement used with OpenMP for loop");
8919 add_stmt (build_predict_expr (PRED_CONTINUE
, NOT_TAKEN
));
8921 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
8924 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
8927 emit_side_effect_warnings (location_t loc
, tree expr
)
8929 if (expr
== error_mark_node
)
8931 else if (!TREE_SIDE_EFFECTS (expr
))
8933 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
8934 warning_at (loc
, OPT_Wunused_value
, "statement with no effect");
8937 warn_if_unused_value (expr
, loc
);
8940 /* Process an expression as if it were a complete statement. Emit
8941 diagnostics, but do not call ADD_STMT. LOC is the location of the
8945 c_process_expr_stmt (location_t loc
, tree expr
)
8952 expr
= c_fully_fold (expr
, false, NULL
);
8954 if (warn_sequence_point
)
8955 verify_sequence_points (expr
);
8957 if (TREE_TYPE (expr
) != error_mark_node
8958 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
8959 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
8960 error_at (loc
, "expression statement has incomplete type");
8962 /* If we're not processing a statement expression, warn about unused values.
8963 Warnings for statement expressions will be emitted later, once we figure
8964 out which is the result. */
8965 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
8966 && warn_unused_value
)
8967 emit_side_effect_warnings (loc
, expr
);
8970 while (TREE_CODE (exprv
) == COMPOUND_EXPR
)
8971 exprv
= TREE_OPERAND (exprv
, 1);
8972 if (DECL_P (exprv
) || handled_component_p (exprv
))
8973 mark_exp_read (exprv
);
8975 /* If the expression is not of a type to which we cannot assign a line
8976 number, wrap the thing in a no-op NOP_EXPR. */
8977 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
8979 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
8980 SET_EXPR_LOCATION (expr
, loc
);
8986 /* Emit an expression as a statement. LOC is the location of the
8990 c_finish_expr_stmt (location_t loc
, tree expr
)
8993 return add_stmt (c_process_expr_stmt (loc
, expr
));
8998 /* Do the opposite and emit a statement as an expression. To begin,
8999 create a new binding level and return it. */
9002 c_begin_stmt_expr (void)
9006 /* We must force a BLOCK for this level so that, if it is not expanded
9007 later, there is a way to turn off the entire subtree of blocks that
9008 are contained in it. */
9010 ret
= c_begin_compound_stmt (true);
9012 c_bindings_start_stmt_expr (c_switch_stack
== NULL
9014 : c_switch_stack
->bindings
);
9016 /* Mark the current statement list as belonging to a statement list. */
9017 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
9022 /* LOC is the location of the compound statement to which this body
9026 c_finish_stmt_expr (location_t loc
, tree body
)
9028 tree last
, type
, tmp
, val
;
9031 body
= c_end_compound_stmt (loc
, body
, true);
9033 c_bindings_end_stmt_expr (c_switch_stack
== NULL
9035 : c_switch_stack
->bindings
);
9037 /* Locate the last statement in BODY. See c_end_compound_stmt
9038 about always returning a BIND_EXPR. */
9039 last_p
= &BIND_EXPR_BODY (body
);
9040 last
= BIND_EXPR_BODY (body
);
9043 if (TREE_CODE (last
) == STATEMENT_LIST
)
9045 tree_stmt_iterator i
;
9047 /* This can happen with degenerate cases like ({ }). No value. */
9048 if (!TREE_SIDE_EFFECTS (last
))
9051 /* If we're supposed to generate side effects warnings, process
9052 all of the statements except the last. */
9053 if (warn_unused_value
)
9055 for (i
= tsi_start (last
); !tsi_one_before_end_p (i
); tsi_next (&i
))
9058 tree t
= tsi_stmt (i
);
9060 tloc
= EXPR_HAS_LOCATION (t
) ? EXPR_LOCATION (t
) : loc
;
9061 emit_side_effect_warnings (tloc
, t
);
9065 i
= tsi_last (last
);
9066 last_p
= tsi_stmt_ptr (i
);
9070 /* If the end of the list is exception related, then the list was split
9071 by a call to push_cleanup. Continue searching. */
9072 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
9073 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
9075 last_p
= &TREE_OPERAND (last
, 0);
9077 goto continue_searching
;
9080 if (last
== error_mark_node
)
9083 /* In the case that the BIND_EXPR is not necessary, return the
9084 expression out from inside it. */
9085 if (last
== BIND_EXPR_BODY (body
)
9086 && BIND_EXPR_VARS (body
) == NULL
)
9088 /* Even if this looks constant, do not allow it in a constant
9090 last
= c_wrap_maybe_const (last
, true);
9091 /* Do not warn if the return value of a statement expression is
9093 TREE_NO_WARNING (last
) = 1;
9097 /* Extract the type of said expression. */
9098 type
= TREE_TYPE (last
);
9100 /* If we're not returning a value at all, then the BIND_EXPR that
9101 we already have is a fine expression to return. */
9102 if (!type
|| VOID_TYPE_P (type
))
9105 /* Now that we've located the expression containing the value, it seems
9106 silly to make voidify_wrapper_expr repeat the process. Create a
9107 temporary of the appropriate type and stick it in a TARGET_EXPR. */
9108 tmp
= create_tmp_var_raw (type
, NULL
);
9110 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
9111 tree_expr_nonnegative_p giving up immediately. */
9113 if (TREE_CODE (val
) == NOP_EXPR
9114 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
9115 val
= TREE_OPERAND (val
, 0);
9117 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
9118 SET_EXPR_LOCATION (*last_p
, EXPR_LOCATION (last
));
9121 tree t
= build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
9122 SET_EXPR_LOCATION (t
, loc
);
9127 /* Begin and end compound statements. This is as simple as pushing
9128 and popping new statement lists from the tree. */
9131 c_begin_compound_stmt (bool do_scope
)
9133 tree stmt
= push_stmt_list ();
9139 /* End a compound statement. STMT is the statement. LOC is the
9140 location of the compound statement-- this is usually the location
9141 of the opening brace. */
9144 c_end_compound_stmt (location_t loc
, tree stmt
, bool do_scope
)
9150 if (c_dialect_objc ())
9151 objc_clear_super_receiver ();
9152 block
= pop_scope ();
9155 stmt
= pop_stmt_list (stmt
);
9156 stmt
= c_build_bind_expr (loc
, block
, stmt
);
9158 /* If this compound statement is nested immediately inside a statement
9159 expression, then force a BIND_EXPR to be created. Otherwise we'll
9160 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
9161 STATEMENT_LISTs merge, and thus we can lose track of what statement
9164 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
9165 && TREE_CODE (stmt
) != BIND_EXPR
)
9167 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
9168 TREE_SIDE_EFFECTS (stmt
) = 1;
9169 SET_EXPR_LOCATION (stmt
, loc
);
9175 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
9176 when the current scope is exited. EH_ONLY is true when this is not
9177 meant to apply to normal control flow transfer. */
9180 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
9182 enum tree_code code
;
9186 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
9187 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), code
, NULL
, cleanup
);
9189 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
9190 list
= push_stmt_list ();
9191 TREE_OPERAND (stmt
, 0) = list
;
9192 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
9195 /* Build a binary-operation expression without default conversions.
9196 CODE is the kind of expression to build.
9197 LOCATION is the operator's location.
9198 This function differs from `build' in several ways:
9199 the data type of the result is computed and recorded in it,
9200 warnings are generated if arg data types are invalid,
9201 special handling for addition and subtraction of pointers is known,
9202 and some optimization is done (operations on narrow ints
9203 are done in the narrower type when that gives the same result).
9204 Constant folding is also done before the result is returned.
9206 Note that the operands will never have enumeral types, or function
9207 or array types, because either they will have the default conversions
9208 performed or they have both just been converted to some other type in which
9209 the arithmetic is to be done. */
9212 build_binary_op (location_t location
, enum tree_code code
,
9213 tree orig_op0
, tree orig_op1
, int convert_p
)
9215 tree type0
, type1
, orig_type0
, orig_type1
;
9217 enum tree_code code0
, code1
;
9219 tree ret
= error_mark_node
;
9220 const char *invalid_op_diag
;
9221 bool op0_int_operands
, op1_int_operands
;
9222 bool int_const
, int_const_or_overflow
, int_operands
;
9224 /* Expression code to give to the expression when it is built.
9225 Normally this is CODE, which is what the caller asked for,
9226 but in some special cases we change it. */
9227 enum tree_code resultcode
= code
;
9229 /* Data type in which the computation is to be performed.
9230 In the simplest cases this is the common type of the arguments. */
9231 tree result_type
= NULL
;
9233 /* When the computation is in excess precision, the type of the
9234 final EXCESS_PRECISION_EXPR. */
9235 tree semantic_result_type
= NULL
;
9237 /* Nonzero means operands have already been type-converted
9238 in whatever way is necessary.
9239 Zero means they need to be converted to RESULT_TYPE. */
9242 /* Nonzero means create the expression with this type, rather than
9244 tree build_type
= 0;
9246 /* Nonzero means after finally constructing the expression
9247 convert it to this type. */
9248 tree final_type
= 0;
9250 /* Nonzero if this is an operation like MIN or MAX which can
9251 safely be computed in short if both args are promoted shorts.
9252 Also implies COMMON.
9253 -1 indicates a bitwise operation; this makes a difference
9254 in the exact conditions for when it is safe to do the operation
9255 in a narrower mode. */
9258 /* Nonzero if this is a comparison operation;
9259 if both args are promoted shorts, compare the original shorts.
9260 Also implies COMMON. */
9261 int short_compare
= 0;
9263 /* Nonzero if this is a right-shift operation, which can be computed on the
9264 original short and then promoted if the operand is a promoted short. */
9265 int short_shift
= 0;
9267 /* Nonzero means set RESULT_TYPE to the common type of the args. */
9270 /* True means types are compatible as far as ObjC is concerned. */
9273 /* True means this is an arithmetic operation that may need excess
9275 bool may_need_excess_precision
;
9277 if (location
== UNKNOWN_LOCATION
)
9278 location
= input_location
;
9283 op0_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op0
);
9284 if (op0_int_operands
)
9285 op0
= remove_c_maybe_const_expr (op0
);
9286 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
9287 if (op1_int_operands
)
9288 op1
= remove_c_maybe_const_expr (op1
);
9289 int_operands
= (op0_int_operands
&& op1_int_operands
);
9292 int_const_or_overflow
= (TREE_CODE (orig_op0
) == INTEGER_CST
9293 && TREE_CODE (orig_op1
) == INTEGER_CST
);
9294 int_const
= (int_const_or_overflow
9295 && !TREE_OVERFLOW (orig_op0
)
9296 && !TREE_OVERFLOW (orig_op1
));
9299 int_const
= int_const_or_overflow
= false;
9303 op0
= default_conversion (op0
);
9304 op1
= default_conversion (op1
);
9307 orig_type0
= type0
= TREE_TYPE (op0
);
9308 orig_type1
= type1
= TREE_TYPE (op1
);
9310 /* The expression codes of the data types of the arguments tell us
9311 whether the arguments are integers, floating, pointers, etc. */
9312 code0
= TREE_CODE (type0
);
9313 code1
= TREE_CODE (type1
);
9315 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
9316 STRIP_TYPE_NOPS (op0
);
9317 STRIP_TYPE_NOPS (op1
);
9319 /* If an error was already reported for one of the arguments,
9320 avoid reporting another error. */
9322 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
9323 return error_mark_node
;
9325 if ((invalid_op_diag
9326 = targetm
.invalid_binary_op (code
, type0
, type1
)))
9328 error_at (location
, invalid_op_diag
);
9329 return error_mark_node
;
9337 case TRUNC_DIV_EXPR
:
9339 case FLOOR_DIV_EXPR
:
9340 case ROUND_DIV_EXPR
:
9341 case EXACT_DIV_EXPR
:
9342 may_need_excess_precision
= true;
9345 may_need_excess_precision
= false;
9348 if (TREE_CODE (op0
) == EXCESS_PRECISION_EXPR
)
9350 op0
= TREE_OPERAND (op0
, 0);
9351 type0
= TREE_TYPE (op0
);
9353 else if (may_need_excess_precision
9354 && (eptype
= excess_precision_type (type0
)) != NULL_TREE
)
9357 op0
= convert (eptype
, op0
);
9359 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
9361 op1
= TREE_OPERAND (op1
, 0);
9362 type1
= TREE_TYPE (op1
);
9364 else if (may_need_excess_precision
9365 && (eptype
= excess_precision_type (type1
)) != NULL_TREE
)
9368 op1
= convert (eptype
, op1
);
9371 objc_ok
= objc_compare_types (type0
, type1
, -3, NULL_TREE
);
9376 /* Handle the pointer + int case. */
9377 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9379 ret
= pointer_int_sum (location
, PLUS_EXPR
, op0
, op1
);
9380 goto return_build_binary_op
;
9382 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
9384 ret
= pointer_int_sum (location
, PLUS_EXPR
, op1
, op0
);
9385 goto return_build_binary_op
;
9392 /* Subtraction of two similar pointers.
9393 We must subtract them as integers, then divide by object size. */
9394 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
9395 && comp_target_types (location
, type0
, type1
))
9397 ret
= pointer_diff (location
, op0
, op1
);
9398 goto return_build_binary_op
;
9400 /* Handle pointer minus int. Just like pointer plus int. */
9401 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9403 ret
= pointer_int_sum (location
, MINUS_EXPR
, op0
, op1
);
9404 goto return_build_binary_op
;
9414 case TRUNC_DIV_EXPR
:
9416 case FLOOR_DIV_EXPR
:
9417 case ROUND_DIV_EXPR
:
9418 case EXACT_DIV_EXPR
:
9419 warn_for_div_by_zero (location
, op1
);
9421 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
9422 || code0
== FIXED_POINT_TYPE
9423 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
9424 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
9425 || code1
== FIXED_POINT_TYPE
9426 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
9428 enum tree_code tcode0
= code0
, tcode1
= code1
;
9430 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
9431 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
9432 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
9433 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
9435 if (!((tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
)
9436 || (tcode0
== FIXED_POINT_TYPE
&& tcode1
== FIXED_POINT_TYPE
)))
9437 resultcode
= RDIV_EXPR
;
9439 /* Although it would be tempting to shorten always here, that
9440 loses on some targets, since the modulo instruction is
9441 undefined if the quotient can't be represented in the
9442 computation mode. We shorten only if unsigned or if
9443 dividing by something we know != -1. */
9444 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
9445 || (TREE_CODE (op1
) == INTEGER_CST
9446 && !integer_all_onesp (op1
)));
9454 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
9456 /* Allow vector types which are not floating point types. */
9457 else if (code0
== VECTOR_TYPE
9458 && code1
== VECTOR_TYPE
9459 && !VECTOR_FLOAT_TYPE_P (type0
)
9460 && !VECTOR_FLOAT_TYPE_P (type1
))
9464 case TRUNC_MOD_EXPR
:
9465 case FLOOR_MOD_EXPR
:
9466 warn_for_div_by_zero (location
, op1
);
9468 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
9469 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
9470 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
9472 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
9474 /* Although it would be tempting to shorten always here, that loses
9475 on some targets, since the modulo instruction is undefined if the
9476 quotient can't be represented in the computation mode. We shorten
9477 only if unsigned or if dividing by something we know != -1. */
9478 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
9479 || (TREE_CODE (op1
) == INTEGER_CST
9480 && !integer_all_onesp (op1
)));
9485 case TRUTH_ANDIF_EXPR
:
9486 case TRUTH_ORIF_EXPR
:
9487 case TRUTH_AND_EXPR
:
9489 case TRUTH_XOR_EXPR
:
9490 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
9491 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
9492 || code0
== FIXED_POINT_TYPE
)
9493 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
9494 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
9495 || code1
== FIXED_POINT_TYPE
))
9497 /* Result of these operations is always an int,
9498 but that does not mean the operands should be
9499 converted to ints! */
9500 result_type
= integer_type_node
;
9501 op0
= c_common_truthvalue_conversion (location
, op0
);
9502 op1
= c_common_truthvalue_conversion (location
, op1
);
9505 if (code
== TRUTH_ANDIF_EXPR
)
9507 int_const_or_overflow
= (int_operands
9508 && TREE_CODE (orig_op0
) == INTEGER_CST
9509 && (op0
== truthvalue_false_node
9510 || TREE_CODE (orig_op1
) == INTEGER_CST
));
9511 int_const
= (int_const_or_overflow
9512 && !TREE_OVERFLOW (orig_op0
)
9513 && (op0
== truthvalue_false_node
9514 || !TREE_OVERFLOW (orig_op1
)));
9516 else if (code
== TRUTH_ORIF_EXPR
)
9518 int_const_or_overflow
= (int_operands
9519 && TREE_CODE (orig_op0
) == INTEGER_CST
9520 && (op0
== truthvalue_true_node
9521 || TREE_CODE (orig_op1
) == INTEGER_CST
));
9522 int_const
= (int_const_or_overflow
9523 && !TREE_OVERFLOW (orig_op0
)
9524 && (op0
== truthvalue_true_node
9525 || !TREE_OVERFLOW (orig_op1
)));
9529 /* Shift operations: result has same type as first operand;
9530 always convert second operand to int.
9531 Also set SHORT_SHIFT if shifting rightward. */
9534 if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
)
9535 && code1
== INTEGER_TYPE
)
9537 if (TREE_CODE (op1
) == INTEGER_CST
)
9539 if (tree_int_cst_sgn (op1
) < 0)
9542 if (c_inhibit_evaluation_warnings
== 0)
9543 warning (0, "right shift count is negative");
9547 if (!integer_zerop (op1
))
9550 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
9553 if (c_inhibit_evaluation_warnings
== 0)
9554 warning (0, "right shift count >= width of type");
9559 /* Use the type of the value to be shifted. */
9560 result_type
= type0
;
9561 /* Convert the shift-count to an integer, regardless of size
9562 of value being shifted. */
9563 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
9564 op1
= convert (integer_type_node
, op1
);
9565 /* Avoid converting op1 to result_type later. */
9571 if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
)
9572 && code1
== INTEGER_TYPE
)
9574 if (TREE_CODE (op1
) == INTEGER_CST
)
9576 if (tree_int_cst_sgn (op1
) < 0)
9579 if (c_inhibit_evaluation_warnings
== 0)
9580 warning (0, "left shift count is negative");
9583 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
9586 if (c_inhibit_evaluation_warnings
== 0)
9587 warning (0, "left shift count >= width of type");
9591 /* Use the type of the value to be shifted. */
9592 result_type
= type0
;
9593 /* Convert the shift-count to an integer, regardless of size
9594 of value being shifted. */
9595 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
9596 op1
= convert (integer_type_node
, op1
);
9597 /* Avoid converting op1 to result_type later. */
9604 if (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
))
9605 warning_at (location
,
9607 "comparing floating point with == or != is unsafe");
9608 /* Result of comparison is always int,
9609 but don't convert the args to int! */
9610 build_type
= integer_type_node
;
9611 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
9612 || code0
== FIXED_POINT_TYPE
|| code0
== COMPLEX_TYPE
)
9613 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
9614 || code1
== FIXED_POINT_TYPE
|| code1
== COMPLEX_TYPE
))
9616 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
9618 if (TREE_CODE (op0
) == ADDR_EXPR
9619 && decl_with_nonnull_addr_p (TREE_OPERAND (op0
, 0)))
9621 if (code
== EQ_EXPR
)
9622 warning_at (location
,
9624 "the comparison will always evaluate as %<false%> "
9625 "for the address of %qD will never be NULL",
9626 TREE_OPERAND (op0
, 0));
9628 warning_at (location
,
9630 "the comparison will always evaluate as %<true%> "
9631 "for the address of %qD will never be NULL",
9632 TREE_OPERAND (op0
, 0));
9634 result_type
= type0
;
9636 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
9638 if (TREE_CODE (op1
) == ADDR_EXPR
9639 && decl_with_nonnull_addr_p (TREE_OPERAND (op1
, 0)))
9641 if (code
== EQ_EXPR
)
9642 warning_at (location
,
9644 "the comparison will always evaluate as %<false%> "
9645 "for the address of %qD will never be NULL",
9646 TREE_OPERAND (op1
, 0));
9648 warning_at (location
,
9650 "the comparison will always evaluate as %<true%> "
9651 "for the address of %qD will never be NULL",
9652 TREE_OPERAND (op1
, 0));
9654 result_type
= type1
;
9656 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
9658 tree tt0
= TREE_TYPE (type0
);
9659 tree tt1
= TREE_TYPE (type1
);
9660 addr_space_t as0
= TYPE_ADDR_SPACE (tt0
);
9661 addr_space_t as1
= TYPE_ADDR_SPACE (tt1
);
9662 addr_space_t as_common
= ADDR_SPACE_GENERIC
;
9664 /* Anything compares with void *. void * compares with anything.
9665 Otherwise, the targets must be compatible
9666 and both must be object or both incomplete. */
9667 if (comp_target_types (location
, type0
, type1
))
9668 result_type
= common_pointer_type (type0
, type1
);
9669 else if (!addr_space_superset (as0
, as1
, &as_common
))
9671 error_at (location
, "comparison of pointers to "
9672 "disjoint address spaces");
9673 return error_mark_node
;
9675 else if (VOID_TYPE_P (tt0
))
9677 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
)
9678 pedwarn (location
, OPT_pedantic
, "ISO C forbids "
9679 "comparison of %<void *%> with function pointer");
9681 else if (VOID_TYPE_P (tt1
))
9683 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
)
9684 pedwarn (location
, OPT_pedantic
, "ISO C forbids "
9685 "comparison of %<void *%> with function pointer");
9688 /* Avoid warning about the volatile ObjC EH puts on decls. */
9690 pedwarn (location
, 0,
9691 "comparison of distinct pointer types lacks a cast");
9693 if (result_type
== NULL_TREE
)
9695 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
9696 result_type
= build_pointer_type
9697 (build_qualified_type (void_type_node
, qual
));
9700 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9702 result_type
= type0
;
9703 pedwarn (location
, 0, "comparison between pointer and integer");
9705 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
9707 result_type
= type1
;
9708 pedwarn (location
, 0, "comparison between pointer and integer");
9716 build_type
= integer_type_node
;
9717 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
9718 || code0
== FIXED_POINT_TYPE
)
9719 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
9720 || code1
== FIXED_POINT_TYPE
))
9722 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
9724 addr_space_t as0
= TYPE_ADDR_SPACE (TREE_TYPE (type0
));
9725 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
9726 addr_space_t as_common
;
9728 if (comp_target_types (location
, type0
, type1
))
9730 result_type
= common_pointer_type (type0
, type1
);
9731 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
9732 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
9733 pedwarn (location
, 0,
9734 "comparison of complete and incomplete pointers");
9735 else if (TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
9736 pedwarn (location
, OPT_pedantic
, "ISO C forbids "
9737 "ordered comparisons of pointers to functions");
9738 else if (null_pointer_constant_p (orig_op0
)
9739 || null_pointer_constant_p (orig_op1
))
9740 warning_at (location
, OPT_Wextra
,
9741 "ordered comparison of pointer with null pointer");
9744 else if (!addr_space_superset (as0
, as1
, &as_common
))
9746 error_at (location
, "comparison of pointers to "
9747 "disjoint address spaces");
9748 return error_mark_node
;
9752 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
9753 result_type
= build_pointer_type
9754 (build_qualified_type (void_type_node
, qual
));
9755 pedwarn (location
, 0,
9756 "comparison of distinct pointer types lacks a cast");
9759 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
9761 result_type
= type0
;
9763 pedwarn (location
, OPT_pedantic
,
9764 "ordered comparison of pointer with integer zero");
9765 else if (extra_warnings
)
9766 warning_at (location
, OPT_Wextra
,
9767 "ordered comparison of pointer with integer zero");
9769 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
9771 result_type
= type1
;
9773 pedwarn (location
, OPT_pedantic
,
9774 "ordered comparison of pointer with integer zero");
9775 else if (extra_warnings
)
9776 warning_at (location
, OPT_Wextra
,
9777 "ordered comparison of pointer with integer zero");
9779 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
9781 result_type
= type0
;
9782 pedwarn (location
, 0, "comparison between pointer and integer");
9784 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
9786 result_type
= type1
;
9787 pedwarn (location
, 0, "comparison between pointer and integer");
9795 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
9796 return error_mark_node
;
9798 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
9799 && (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
9800 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0
),
9801 TREE_TYPE (type1
))))
9803 binary_op_error (location
, code
, type0
, type1
);
9804 return error_mark_node
;
9807 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
9808 || code0
== FIXED_POINT_TYPE
|| code0
== VECTOR_TYPE
)
9810 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
9811 || code1
== FIXED_POINT_TYPE
|| code1
== VECTOR_TYPE
))
9813 bool first_complex
= (code0
== COMPLEX_TYPE
);
9814 bool second_complex
= (code1
== COMPLEX_TYPE
);
9815 int none_complex
= (!first_complex
&& !second_complex
);
9817 if (shorten
|| common
|| short_compare
)
9819 result_type
= c_common_type (type0
, type1
);
9820 if (result_type
== error_mark_node
)
9821 return error_mark_node
;
9824 if (first_complex
!= second_complex
9825 && (code
== PLUS_EXPR
9826 || code
== MINUS_EXPR
9827 || code
== MULT_EXPR
9828 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
9829 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
9830 && flag_signed_zeros
)
9832 /* An operation on mixed real/complex operands must be
9833 handled specially, but the language-independent code can
9834 more easily optimize the plain complex arithmetic if
9835 -fno-signed-zeros. */
9836 tree real_type
= TREE_TYPE (result_type
);
9838 if (type0
!= orig_type0
|| type1
!= orig_type1
)
9840 gcc_assert (may_need_excess_precision
&& common
);
9841 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
9845 if (TREE_TYPE (op0
) != result_type
)
9846 op0
= convert_and_check (result_type
, op0
);
9847 if (TREE_TYPE (op1
) != real_type
)
9848 op1
= convert_and_check (real_type
, op1
);
9852 if (TREE_TYPE (op0
) != real_type
)
9853 op0
= convert_and_check (real_type
, op0
);
9854 if (TREE_TYPE (op1
) != result_type
)
9855 op1
= convert_and_check (result_type
, op1
);
9857 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
9858 return error_mark_node
;
9861 op0
= c_save_expr (op0
);
9862 real
= build_unary_op (EXPR_LOCATION (orig_op0
), REALPART_EXPR
,
9864 imag
= build_unary_op (EXPR_LOCATION (orig_op0
), IMAGPART_EXPR
,
9869 case TRUNC_DIV_EXPR
:
9870 imag
= build2 (resultcode
, real_type
, imag
, op1
);
9874 real
= build2 (resultcode
, real_type
, real
, op1
);
9882 op1
= c_save_expr (op1
);
9883 real
= build_unary_op (EXPR_LOCATION (orig_op1
), REALPART_EXPR
,
9885 imag
= build_unary_op (EXPR_LOCATION (orig_op1
), IMAGPART_EXPR
,
9890 imag
= build2 (resultcode
, real_type
, op0
, imag
);
9893 real
= build2 (resultcode
, real_type
, op0
, real
);
9896 real
= build2 (resultcode
, real_type
, op0
, real
);
9897 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
9903 ret
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
9904 goto return_build_binary_op
;
9907 /* For certain operations (which identify themselves by shorten != 0)
9908 if both args were extended from the same smaller type,
9909 do the arithmetic in that type and then extend.
9911 shorten !=0 and !=1 indicates a bitwise operation.
9912 For them, this optimization is safe only if
9913 both args are zero-extended or both are sign-extended.
9914 Otherwise, we might change the result.
9915 Eg, (short)-1 | (unsigned short)-1 is (int)-1
9916 but calculated in (unsigned short) it would be (unsigned short)-1. */
9918 if (shorten
&& none_complex
)
9920 final_type
= result_type
;
9921 result_type
= shorten_binary_op (result_type
, op0
, op1
,
9925 /* Shifts can be shortened if shifting right. */
9930 tree arg0
= get_narrower (op0
, &unsigned_arg
);
9932 final_type
= result_type
;
9934 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
9935 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
9937 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
9938 && tree_int_cst_sgn (op1
) > 0
9939 /* We can shorten only if the shift count is less than the
9940 number of bits in the smaller type size. */
9941 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
9942 /* We cannot drop an unsigned shift after sign-extension. */
9943 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
9945 /* Do an unsigned shift if the operand was zero-extended. */
9947 = c_common_signed_or_unsigned_type (unsigned_arg
,
9949 /* Convert value-to-be-shifted to that type. */
9950 if (TREE_TYPE (op0
) != result_type
)
9951 op0
= convert (result_type
, op0
);
9956 /* Comparison operations are shortened too but differently.
9957 They identify themselves by setting short_compare = 1. */
9961 /* Don't write &op0, etc., because that would prevent op0
9962 from being kept in a register.
9963 Instead, make copies of the our local variables and
9964 pass the copies by reference, then copy them back afterward. */
9965 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
9966 enum tree_code xresultcode
= resultcode
;
9968 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
9973 goto return_build_binary_op
;
9976 op0
= xop0
, op1
= xop1
;
9978 resultcode
= xresultcode
;
9980 if (c_inhibit_evaluation_warnings
== 0)
9982 bool op0_maybe_const
= true;
9983 bool op1_maybe_const
= true;
9984 tree orig_op0_folded
, orig_op1_folded
;
9986 if (in_late_binary_op
)
9988 orig_op0_folded
= orig_op0
;
9989 orig_op1_folded
= orig_op1
;
9993 /* Fold for the sake of possible warnings, as in
9994 build_conditional_expr. This requires the
9995 "original" values to be folded, not just op0 and
9997 c_inhibit_evaluation_warnings
++;
9998 op0
= c_fully_fold (op0
, require_constant_value
,
10000 op1
= c_fully_fold (op1
, require_constant_value
,
10002 c_inhibit_evaluation_warnings
--;
10003 orig_op0_folded
= c_fully_fold (orig_op0
,
10004 require_constant_value
,
10006 orig_op1_folded
= c_fully_fold (orig_op1
,
10007 require_constant_value
,
10011 if (warn_sign_compare
)
10012 warn_for_sign_compare (location
, orig_op0_folded
,
10013 orig_op1_folded
, op0
, op1
,
10014 result_type
, resultcode
);
10015 if (!in_late_binary_op
)
10017 if (!op0_maybe_const
|| TREE_CODE (op0
) != INTEGER_CST
)
10018 op0
= c_wrap_maybe_const (op0
, !op0_maybe_const
);
10019 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
10020 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
10026 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
10027 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
10028 Then the expression will be built.
10029 It will be given type FINAL_TYPE if that is nonzero;
10030 otherwise, it will be given type RESULT_TYPE. */
10034 binary_op_error (location
, code
, TREE_TYPE (op0
), TREE_TYPE (op1
));
10035 return error_mark_node
;
10038 if (build_type
== NULL_TREE
)
10040 build_type
= result_type
;
10041 if (type0
!= orig_type0
|| type1
!= orig_type1
)
10043 gcc_assert (may_need_excess_precision
&& common
);
10044 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
10050 op0
= ep_convert_and_check (result_type
, op0
, semantic_result_type
);
10051 op1
= ep_convert_and_check (result_type
, op1
, semantic_result_type
);
10053 /* This can happen if one operand has a vector type, and the other
10054 has a different type. */
10055 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
10056 return error_mark_node
;
10059 /* Treat expressions in initializers specially as they can't trap. */
10060 if (int_const_or_overflow
)
10061 ret
= (require_constant_value
10062 ? fold_build2_initializer_loc (location
, resultcode
, build_type
,
10064 : fold_build2_loc (location
, resultcode
, build_type
, op0
, op1
));
10066 ret
= build2 (resultcode
, build_type
, op0
, op1
);
10067 if (final_type
!= 0)
10068 ret
= convert (final_type
, ret
);
10070 return_build_binary_op
:
10071 gcc_assert (ret
!= error_mark_node
);
10072 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
) && !int_const
)
10073 ret
= (int_operands
10074 ? note_integer_operands (ret
)
10075 : build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
));
10076 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
10077 && !in_late_binary_op
)
10078 ret
= note_integer_operands (ret
);
10079 if (semantic_result_type
)
10080 ret
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, ret
);
10081 protected_set_expr_location (ret
, location
);
10086 /* Convert EXPR to be a truth-value, validating its type for this
10087 purpose. LOCATION is the source location for the expression. */
10090 c_objc_common_truthvalue_conversion (location_t location
, tree expr
)
10092 bool int_const
, int_operands
;
10094 switch (TREE_CODE (TREE_TYPE (expr
)))
10097 error_at (location
, "used array that cannot be converted to pointer where scalar is required");
10098 return error_mark_node
;
10101 error_at (location
, "used struct type value where scalar is required");
10102 return error_mark_node
;
10105 error_at (location
, "used union type value where scalar is required");
10106 return error_mark_node
;
10108 case FUNCTION_TYPE
:
10109 gcc_unreachable ();
10115 int_const
= (TREE_CODE (expr
) == INTEGER_CST
&& !TREE_OVERFLOW (expr
));
10116 int_operands
= EXPR_INT_CONST_OPERANDS (expr
);
10118 expr
= remove_c_maybe_const_expr (expr
);
10120 /* ??? Should we also give an error for void and vectors rather than
10121 leaving those to give errors later? */
10122 expr
= c_common_truthvalue_conversion (location
, expr
);
10124 if (TREE_CODE (expr
) == INTEGER_CST
&& int_operands
&& !int_const
)
10126 if (TREE_OVERFLOW (expr
))
10129 return note_integer_operands (expr
);
10131 if (TREE_CODE (expr
) == INTEGER_CST
&& !int_const
)
10132 return build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
10137 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
10141 c_expr_to_decl (tree expr
, bool *tc ATTRIBUTE_UNUSED
, bool *se
)
10143 if (TREE_CODE (expr
) == COMPOUND_LITERAL_EXPR
)
10145 tree decl
= COMPOUND_LITERAL_EXPR_DECL (expr
);
10146 /* Executing a compound literal inside a function reinitializes
10148 if (!TREE_STATIC (decl
))
10156 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10159 c_begin_omp_parallel (void)
10163 keep_next_level ();
10164 block
= c_begin_compound_stmt (true);
10169 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
10170 statement. LOC is the location of the OMP_PARALLEL. */
10173 c_finish_omp_parallel (location_t loc
, tree clauses
, tree block
)
10177 block
= c_end_compound_stmt (loc
, block
, true);
10179 stmt
= make_node (OMP_PARALLEL
);
10180 TREE_TYPE (stmt
) = void_type_node
;
10181 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
10182 OMP_PARALLEL_BODY (stmt
) = block
;
10183 SET_EXPR_LOCATION (stmt
, loc
);
10185 return add_stmt (stmt
);
10188 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10191 c_begin_omp_task (void)
10195 keep_next_level ();
10196 block
= c_begin_compound_stmt (true);
10201 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
10202 statement. LOC is the location of the #pragma. */
10205 c_finish_omp_task (location_t loc
, tree clauses
, tree block
)
10209 block
= c_end_compound_stmt (loc
, block
, true);
10211 stmt
= make_node (OMP_TASK
);
10212 TREE_TYPE (stmt
) = void_type_node
;
10213 OMP_TASK_CLAUSES (stmt
) = clauses
;
10214 OMP_TASK_BODY (stmt
) = block
;
10215 SET_EXPR_LOCATION (stmt
, loc
);
10217 return add_stmt (stmt
);
10220 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
10221 Remove any elements from the list that are invalid. */
10224 c_finish_omp_clauses (tree clauses
)
10226 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
10227 tree c
, t
, *pc
= &clauses
;
10230 bitmap_obstack_initialize (NULL
);
10231 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
10232 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
10233 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
10235 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
10237 bool remove
= false;
10238 bool need_complete
= false;
10239 bool need_implicitly_determined
= false;
10241 switch (OMP_CLAUSE_CODE (c
))
10243 case OMP_CLAUSE_SHARED
:
10245 need_implicitly_determined
= true;
10246 goto check_dup_generic
;
10248 case OMP_CLAUSE_PRIVATE
:
10250 need_complete
= true;
10251 need_implicitly_determined
= true;
10252 goto check_dup_generic
;
10254 case OMP_CLAUSE_REDUCTION
:
10255 name
= "reduction";
10256 need_implicitly_determined
= true;
10257 t
= OMP_CLAUSE_DECL (c
);
10258 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
10259 || POINTER_TYPE_P (TREE_TYPE (t
)))
10261 error_at (OMP_CLAUSE_LOCATION (c
),
10262 "%qE has invalid type for %<reduction%>", t
);
10265 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
10267 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
10268 const char *r_name
= NULL
;
10285 case TRUTH_ANDIF_EXPR
:
10288 case TRUTH_ORIF_EXPR
:
10292 gcc_unreachable ();
10296 error_at (OMP_CLAUSE_LOCATION (c
),
10297 "%qE has invalid type for %<reduction(%s)%>",
10302 goto check_dup_generic
;
10304 case OMP_CLAUSE_COPYPRIVATE
:
10305 name
= "copyprivate";
10306 goto check_dup_generic
;
10308 case OMP_CLAUSE_COPYIN
:
10310 t
= OMP_CLAUSE_DECL (c
);
10311 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
10313 error_at (OMP_CLAUSE_LOCATION (c
),
10314 "%qE must be %<threadprivate%> for %<copyin%>", t
);
10317 goto check_dup_generic
;
10320 t
= OMP_CLAUSE_DECL (c
);
10321 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10323 error_at (OMP_CLAUSE_LOCATION (c
),
10324 "%qE is not a variable in clause %qs", t
, name
);
10327 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
10328 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
10329 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
10331 error_at (OMP_CLAUSE_LOCATION (c
),
10332 "%qE appears more than once in data clauses", t
);
10336 bitmap_set_bit (&generic_head
, DECL_UID (t
));
10339 case OMP_CLAUSE_FIRSTPRIVATE
:
10340 name
= "firstprivate";
10341 t
= OMP_CLAUSE_DECL (c
);
10342 need_complete
= true;
10343 need_implicitly_determined
= true;
10344 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10346 error_at (OMP_CLAUSE_LOCATION (c
),
10347 "%qE is not a variable in clause %<firstprivate%>", t
);
10350 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
10351 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
10353 error_at (OMP_CLAUSE_LOCATION (c
),
10354 "%qE appears more than once in data clauses", t
);
10358 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
10361 case OMP_CLAUSE_LASTPRIVATE
:
10362 name
= "lastprivate";
10363 t
= OMP_CLAUSE_DECL (c
);
10364 need_complete
= true;
10365 need_implicitly_determined
= true;
10366 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10368 error_at (OMP_CLAUSE_LOCATION (c
),
10369 "%qE is not a variable in clause %<lastprivate%>", t
);
10372 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
10373 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
10375 error_at (OMP_CLAUSE_LOCATION (c
),
10376 "%qE appears more than once in data clauses", t
);
10380 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
10383 case OMP_CLAUSE_IF
:
10384 case OMP_CLAUSE_NUM_THREADS
:
10385 case OMP_CLAUSE_SCHEDULE
:
10386 case OMP_CLAUSE_NOWAIT
:
10387 case OMP_CLAUSE_ORDERED
:
10388 case OMP_CLAUSE_DEFAULT
:
10389 case OMP_CLAUSE_UNTIED
:
10390 case OMP_CLAUSE_COLLAPSE
:
10391 pc
= &OMP_CLAUSE_CHAIN (c
);
10395 gcc_unreachable ();
10400 t
= OMP_CLAUSE_DECL (c
);
10404 t
= require_complete_type (t
);
10405 if (t
== error_mark_node
)
10409 if (need_implicitly_determined
)
10411 const char *share_name
= NULL
;
10413 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
10414 share_name
= "threadprivate";
10415 else switch (c_omp_predetermined_sharing (t
))
10417 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
10419 case OMP_CLAUSE_DEFAULT_SHARED
:
10420 share_name
= "shared";
10422 case OMP_CLAUSE_DEFAULT_PRIVATE
:
10423 share_name
= "private";
10426 gcc_unreachable ();
10430 error_at (OMP_CLAUSE_LOCATION (c
),
10431 "%qE is predetermined %qs for %qs",
10432 t
, share_name
, name
);
10439 *pc
= OMP_CLAUSE_CHAIN (c
);
10441 pc
= &OMP_CLAUSE_CHAIN (c
);
10444 bitmap_obstack_release (NULL
);
10448 /* Make a variant type in the proper way for C/C++, propagating qualifiers
10449 down to the element type of an array. */
10452 c_build_qualified_type (tree type
, int type_quals
)
10454 if (type
== error_mark_node
)
10457 if (TREE_CODE (type
) == ARRAY_TYPE
)
10460 tree element_type
= c_build_qualified_type (TREE_TYPE (type
),
10463 /* See if we already have an identically qualified type. */
10464 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10466 if (TYPE_QUALS (strip_array_types (t
)) == type_quals
10467 && TYPE_NAME (t
) == TYPE_NAME (type
)
10468 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
10469 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
10470 TYPE_ATTRIBUTES (type
)))
10475 tree domain
= TYPE_DOMAIN (type
);
10477 t
= build_variant_type_copy (type
);
10478 TREE_TYPE (t
) = element_type
;
10480 if (TYPE_STRUCTURAL_EQUALITY_P (element_type
)
10481 || (domain
&& TYPE_STRUCTURAL_EQUALITY_P (domain
)))
10482 SET_TYPE_STRUCTURAL_EQUALITY (t
);
10483 else if (TYPE_CANONICAL (element_type
) != element_type
10484 || (domain
&& TYPE_CANONICAL (domain
) != domain
))
10486 tree unqualified_canon
10487 = build_array_type (TYPE_CANONICAL (element_type
),
10488 domain
? TYPE_CANONICAL (domain
)
10491 = c_build_qualified_type (unqualified_canon
, type_quals
);
10494 TYPE_CANONICAL (t
) = t
;
10499 /* A restrict-qualified pointer type must be a pointer to object or
10500 incomplete type. Note that the use of POINTER_TYPE_P also allows
10501 REFERENCE_TYPEs, which is appropriate for C++. */
10502 if ((type_quals
& TYPE_QUAL_RESTRICT
)
10503 && (!POINTER_TYPE_P (type
)
10504 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
10506 error ("invalid use of %<restrict%>");
10507 type_quals
&= ~TYPE_QUAL_RESTRICT
;
10510 return build_qualified_type (type
, type_quals
);
10513 /* Build a VA_ARG_EXPR for the C parser. */
10516 c_build_va_arg (location_t loc
, tree expr
, tree type
)
10518 if (warn_cxx_compat
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
10519 warning_at (loc
, OPT_Wc___compat
,
10520 "C++ requires promoted type, not enum type, in %<va_arg%>");
10521 return build_va_arg (loc
, expr
, type
);