1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This file is part of the C front end.
24 It contains routines to build C expressions given their operands,
25 including computing the types of the result, C-specific error checks,
26 and some optimization.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
34 #include "coretypes.h"
48 /* Nonzero if we've already printed a "missing braces around initializer"
49 message within this initializer. */
50 static int missing_braces_mentioned
;
52 /* 1 if we explained undeclared var errors. */
53 static int undeclared_variable_notice
;
55 static tree qualify_type
PARAMS ((tree
, tree
));
56 static int comp_target_types
PARAMS ((tree
, tree
, int));
57 static int function_types_compatible_p
PARAMS ((tree
, tree
));
58 static int type_lists_compatible_p
PARAMS ((tree
, tree
));
59 static tree decl_constant_value_for_broken_optimization
PARAMS ((tree
));
60 static tree default_function_array_conversion
PARAMS ((tree
));
61 static tree lookup_field
PARAMS ((tree
, tree
));
62 static tree convert_arguments
PARAMS ((tree
, tree
, tree
, tree
));
63 static tree pointer_diff
PARAMS ((tree
, tree
));
64 static tree unary_complex_lvalue
PARAMS ((enum tree_code
, tree
, int));
65 static void pedantic_lvalue_warning
PARAMS ((enum tree_code
));
66 static tree internal_build_compound_expr
PARAMS ((tree
, int));
67 static tree convert_for_assignment
PARAMS ((tree
, tree
, const char *,
69 static void warn_for_assignment
PARAMS ((const char *, const char *,
71 static tree valid_compound_expr_initializer
PARAMS ((tree
, tree
));
72 static void push_string
PARAMS ((const char *));
73 static void push_member_name
PARAMS ((tree
));
74 static void push_array_bounds
PARAMS ((int));
75 static int spelling_length
PARAMS ((void));
76 static char *print_spelling
PARAMS ((char *));
77 static void warning_init
PARAMS ((const char *));
78 static tree digest_init
PARAMS ((tree
, tree
, int));
79 static void output_init_element
PARAMS ((tree
, tree
, tree
, int));
80 static void output_pending_init_elements
PARAMS ((int));
81 static int set_designator
PARAMS ((int));
82 static void push_range_stack
PARAMS ((tree
));
83 static void add_pending_init
PARAMS ((tree
, tree
));
84 static void set_nonincremental_init
PARAMS ((void));
85 static void set_nonincremental_init_from_string
PARAMS ((tree
));
86 static tree find_init_member
PARAMS ((tree
));
88 /* Do `exp = require_complete_type (exp);' to make sure exp
89 does not have an incomplete type. (That includes void types.) */
92 require_complete_type (value
)
95 tree type
= TREE_TYPE (value
);
97 if (value
== error_mark_node
|| type
== error_mark_node
)
98 return error_mark_node
;
100 /* First, detect a valid value with a complete type. */
101 if (COMPLETE_TYPE_P (type
))
104 c_incomplete_type_error (value
, type
);
105 return error_mark_node
;
108 /* Print an error message for invalid use of an incomplete type.
109 VALUE is the expression that was used (or 0 if that isn't known)
110 and TYPE is the type that was invalid. */
113 c_incomplete_type_error (value
, type
)
117 const char *type_code_string
;
119 /* Avoid duplicate error message. */
120 if (TREE_CODE (type
) == ERROR_MARK
)
123 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
124 || TREE_CODE (value
) == PARM_DECL
))
125 error ("`%s' has an incomplete type",
126 IDENTIFIER_POINTER (DECL_NAME (value
)));
130 /* We must print an error message. Be clever about what it says. */
132 switch (TREE_CODE (type
))
135 type_code_string
= "struct";
139 type_code_string
= "union";
143 type_code_string
= "enum";
147 error ("invalid use of void expression");
151 if (TYPE_DOMAIN (type
))
153 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL
)
155 error ("invalid use of flexible array member");
158 type
= TREE_TYPE (type
);
161 error ("invalid use of array with unspecified bounds");
168 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
169 error ("invalid use of undefined type `%s %s'",
170 type_code_string
, IDENTIFIER_POINTER (TYPE_NAME (type
)));
172 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
173 error ("invalid use of incomplete typedef `%s'",
174 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
))));
178 /* Given a type, apply default promotions wrt unnamed function
179 arguments and return the new type. */
182 c_type_promotes_to (type
)
185 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
186 return double_type_node
;
188 if (c_promoting_integer_type_p (type
))
190 /* Preserve unsignedness if not really getting any wider. */
191 if (TREE_UNSIGNED (type
)
192 && (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
193 return unsigned_type_node
;
194 return integer_type_node
;
200 /* Return a variant of TYPE which has all the type qualifiers of LIKE
201 as well as those of TYPE. */
204 qualify_type (type
, like
)
207 return c_build_qualified_type (type
,
208 TYPE_QUALS (type
) | TYPE_QUALS (like
));
211 /* Return the common type of two types.
212 We assume that comptypes has already been done and returned 1;
213 if that isn't so, this may crash. In particular, we assume that qualifiers
216 This is the type for the result of most arithmetic operations
217 if the operands have the given two types. */
223 enum tree_code code1
;
224 enum tree_code code2
;
227 /* Save time if the two types are the same. */
229 if (t1
== t2
) return t1
;
231 /* If one type is nonsense, use the other. */
232 if (t1
== error_mark_node
)
234 if (t2
== error_mark_node
)
237 /* Merge the attributes. */
238 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
240 /* Treat an enum type as the unsigned integer type of the same width. */
242 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
243 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), 1);
244 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
245 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), 1);
247 code1
= TREE_CODE (t1
);
248 code2
= TREE_CODE (t2
);
250 /* If one type is complex, form the common type of the non-complex
251 components, then make that complex. Use T1 or T2 if it is the
253 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
255 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
256 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
257 tree subtype
= common_type (subtype1
, subtype2
);
259 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
260 return build_type_attribute_variant (t1
, attributes
);
261 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
262 return build_type_attribute_variant (t2
, attributes
);
264 return build_type_attribute_variant (build_complex_type (subtype
),
272 /* If only one is real, use it as the result. */
274 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
275 return build_type_attribute_variant (t1
, attributes
);
277 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
278 return build_type_attribute_variant (t2
, attributes
);
280 /* Both real or both integers; use the one with greater precision. */
282 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
283 return build_type_attribute_variant (t1
, attributes
);
284 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
285 return build_type_attribute_variant (t2
, attributes
);
287 /* Same precision. Prefer longs to ints even when same size. */
289 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
290 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
291 return build_type_attribute_variant (long_unsigned_type_node
,
294 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
295 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
297 /* But preserve unsignedness from the other type,
298 since long cannot hold all the values of an unsigned int. */
299 if (TREE_UNSIGNED (t1
) || TREE_UNSIGNED (t2
))
300 t1
= long_unsigned_type_node
;
302 t1
= long_integer_type_node
;
303 return build_type_attribute_variant (t1
, attributes
);
306 /* Likewise, prefer long double to double even if same size. */
307 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
308 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
309 return build_type_attribute_variant (long_double_type_node
,
312 /* Otherwise prefer the unsigned one. */
314 if (TREE_UNSIGNED (t1
))
315 return build_type_attribute_variant (t1
, attributes
);
317 return build_type_attribute_variant (t2
, attributes
);
320 /* For two pointers, do this recursively on the target type,
321 and combine the qualifiers of the two types' targets. */
322 /* This code was turned off; I don't know why.
323 But ANSI C specifies doing this with the qualifiers.
324 So I turned it on again. */
326 tree pointed_to_1
= TREE_TYPE (t1
);
327 tree pointed_to_2
= TREE_TYPE (t2
);
328 tree target
= common_type (TYPE_MAIN_VARIANT (pointed_to_1
),
329 TYPE_MAIN_VARIANT (pointed_to_2
));
330 t1
= build_pointer_type (c_build_qualified_type
332 TYPE_QUALS (pointed_to_1
) |
333 TYPE_QUALS (pointed_to_2
)));
334 return build_type_attribute_variant (t1
, attributes
);
337 t1
= build_pointer_type (common_type (TREE_TYPE (t1
), TREE_TYPE (t2
)));
338 return build_type_attribute_variant (t1
, attributes
);
343 tree elt
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
344 /* Save space: see if the result is identical to one of the args. */
345 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
346 return build_type_attribute_variant (t1
, attributes
);
347 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
348 return build_type_attribute_variant (t2
, attributes
);
349 /* Merge the element types, and have a size if either arg has one. */
350 t1
= build_array_type (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
351 return build_type_attribute_variant (t1
, attributes
);
355 /* Function types: prefer the one that specified arg types.
356 If both do, merge the arg types. Also merge the return types. */
358 tree valtype
= common_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
359 tree p1
= TYPE_ARG_TYPES (t1
);
360 tree p2
= TYPE_ARG_TYPES (t2
);
365 /* Save space: see if the result is identical to one of the args. */
366 if (valtype
== TREE_TYPE (t1
) && ! TYPE_ARG_TYPES (t2
))
367 return build_type_attribute_variant (t1
, attributes
);
368 if (valtype
== TREE_TYPE (t2
) && ! TYPE_ARG_TYPES (t1
))
369 return build_type_attribute_variant (t2
, attributes
);
371 /* Simple way if one arg fails to specify argument types. */
372 if (TYPE_ARG_TYPES (t1
) == 0)
374 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t2
));
375 return build_type_attribute_variant (t1
, attributes
);
377 if (TYPE_ARG_TYPES (t2
) == 0)
379 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t1
));
380 return build_type_attribute_variant (t1
, attributes
);
383 /* If both args specify argument types, we must merge the two
384 lists, argument by argument. */
387 declare_parm_level (1);
389 len
= list_length (p1
);
392 for (i
= 0; i
< len
; i
++)
393 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
398 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
))
400 /* A null type means arg type is not specified.
401 Take whatever the other function type has. */
402 if (TREE_VALUE (p1
) == 0)
404 TREE_VALUE (n
) = TREE_VALUE (p2
);
407 if (TREE_VALUE (p2
) == 0)
409 TREE_VALUE (n
) = TREE_VALUE (p1
);
413 /* Given wait (union {union wait *u; int *i} *)
414 and wait (union wait *),
415 prefer union wait * as type of parm. */
416 if (TREE_CODE (TREE_VALUE (p1
)) == UNION_TYPE
417 && TREE_VALUE (p1
) != TREE_VALUE (p2
))
420 for (memb
= TYPE_FIELDS (TREE_VALUE (p1
));
421 memb
; memb
= TREE_CHAIN (memb
))
422 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (p2
)))
424 TREE_VALUE (n
) = TREE_VALUE (p2
);
426 pedwarn ("function types not truly compatible in ISO C");
430 if (TREE_CODE (TREE_VALUE (p2
)) == UNION_TYPE
431 && TREE_VALUE (p2
) != TREE_VALUE (p1
))
434 for (memb
= TYPE_FIELDS (TREE_VALUE (p2
));
435 memb
; memb
= TREE_CHAIN (memb
))
436 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (p1
)))
438 TREE_VALUE (n
) = TREE_VALUE (p1
);
440 pedwarn ("function types not truly compatible in ISO C");
444 TREE_VALUE (n
) = common_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
450 t1
= build_function_type (valtype
, newargs
);
451 /* ... falls through ... */
455 return build_type_attribute_variant (t1
, attributes
);
460 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
461 or various other operations. Return 2 if they are compatible
462 but a warning may be needed if you use them together. */
465 comptypes (type1
, type2
)
472 /* Suppress errors caused by previously reported errors. */
474 if (t1
== t2
|| !t1
|| !t2
475 || TREE_CODE (t1
) == ERROR_MARK
|| TREE_CODE (t2
) == ERROR_MARK
)
478 /* If either type is the internal version of sizetype, return the
480 if (TREE_CODE (t1
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t1
)
481 && TYPE_DOMAIN (t1
) != 0)
482 t1
= TYPE_DOMAIN (t1
);
484 if (TREE_CODE (t2
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (t2
)
485 && TYPE_DOMAIN (t2
) != 0)
486 t2
= TYPE_DOMAIN (t2
);
488 /* Treat an enum type as the integer type of the same width and
491 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
492 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), TREE_UNSIGNED (t1
));
493 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
494 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), TREE_UNSIGNED (t2
));
499 /* Different classes of types can't be compatible. */
501 if (TREE_CODE (t1
) != TREE_CODE (t2
)) return 0;
503 /* Qualifiers must match. */
505 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
508 /* Allow for two different type nodes which have essentially the same
509 definition. Note that we already checked for equality of the type
510 qualifiers (just above). */
512 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
515 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
516 if (! (attrval
= (*targetm
.comp_type_attributes
) (t1
, t2
)))
519 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
522 switch (TREE_CODE (t1
))
525 val
= (TREE_TYPE (t1
) == TREE_TYPE (t2
)
526 ? 1 : comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
)));
530 val
= function_types_compatible_p (t1
, t2
);
535 tree d1
= TYPE_DOMAIN (t1
);
536 tree d2
= TYPE_DOMAIN (t2
);
537 bool d1_variable
, d2_variable
;
538 bool d1_zero
, d2_zero
;
541 /* Target types must match incl. qualifiers. */
542 if (TREE_TYPE (t1
) != TREE_TYPE (t2
)
543 && 0 == (val
= comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
))))
546 /* Sizes must match unless one is missing or variable. */
547 if (d1
== 0 || d2
== 0 || d1
== d2
)
550 d1_zero
= ! TYPE_MAX_VALUE (d1
);
551 d2_zero
= ! TYPE_MAX_VALUE (d2
);
553 d1_variable
= (! d1_zero
554 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
555 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
556 d2_variable
= (! d2_zero
557 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
558 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
560 if (d1_variable
|| d2_variable
)
562 if (d1_zero
&& d2_zero
)
564 if (d1_zero
|| d2_zero
565 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
))
566 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1
), TYPE_MAX_VALUE (d2
)))
573 if (flag_objc
&& objc_comptypes (t1
, t2
, 0) == 1)
580 return attrval
== 2 && val
== 1 ? 2 : val
;
583 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
584 ignoring their qualifiers. REFLEXIVE is only used by ObjC - set it
585 to 1 or 0 depending if the check of the pointer types is meant to
586 be reflexive or not (typically, assignments are not reflexive,
587 while comparisons are reflexive).
591 comp_target_types (ttl
, ttr
, reflexive
)
597 /* Give objc_comptypes a crack at letting these types through. */
598 if ((val
= objc_comptypes (ttl
, ttr
, reflexive
)) >= 0)
601 val
= comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl
)),
602 TYPE_MAIN_VARIANT (TREE_TYPE (ttr
)));
604 if (val
== 2 && pedantic
)
605 pedwarn ("types are not quite compatible");
609 /* Subroutines of `comptypes'. */
611 /* Return 1 if two function types F1 and F2 are compatible.
612 If either type specifies no argument types,
613 the other must specify a fixed number of self-promoting arg types.
614 Otherwise, if one type specifies only the number of arguments,
615 the other must specify that number of self-promoting arg types.
616 Otherwise, the argument types must match. */
619 function_types_compatible_p (f1
, f2
)
623 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
627 if (!(TREE_TYPE (f1
) == TREE_TYPE (f2
)
628 || (val
= comptypes (TREE_TYPE (f1
), TREE_TYPE (f2
)))))
631 args1
= TYPE_ARG_TYPES (f1
);
632 args2
= TYPE_ARG_TYPES (f2
);
634 /* An unspecified parmlist matches any specified parmlist
635 whose argument types don't need default promotions. */
639 if (!self_promoting_args_p (args2
))
641 /* If one of these types comes from a non-prototype fn definition,
642 compare that with the other type's arglist.
643 If they don't match, ask for a warning (but no error). */
644 if (TYPE_ACTUAL_ARG_TYPES (f1
)
645 && 1 != type_lists_compatible_p (args2
, TYPE_ACTUAL_ARG_TYPES (f1
)))
651 if (!self_promoting_args_p (args1
))
653 if (TYPE_ACTUAL_ARG_TYPES (f2
)
654 && 1 != type_lists_compatible_p (args1
, TYPE_ACTUAL_ARG_TYPES (f2
)))
659 /* Both types have argument lists: compare them and propagate results. */
660 val1
= type_lists_compatible_p (args1
, args2
);
661 return val1
!= 1 ? val1
: val
;
664 /* Check two lists of types for compatibility,
665 returning 0 for incompatible, 1 for compatible,
666 or 2 for compatible with warning. */
669 type_lists_compatible_p (args1
, args2
)
672 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
678 if (args1
== 0 && args2
== 0)
680 /* If one list is shorter than the other,
681 they fail to match. */
682 if (args1
== 0 || args2
== 0)
684 /* A null pointer instead of a type
685 means there is supposed to be an argument
686 but nothing is specified about what type it has.
687 So match anything that self-promotes. */
688 if (TREE_VALUE (args1
) == 0)
690 if (c_type_promotes_to (TREE_VALUE (args2
)) != TREE_VALUE (args2
))
693 else if (TREE_VALUE (args2
) == 0)
695 if (c_type_promotes_to (TREE_VALUE (args1
)) != TREE_VALUE (args1
))
698 else if (! (newval
= comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1
)),
699 TYPE_MAIN_VARIANT (TREE_VALUE (args2
)))))
701 /* Allow wait (union {union wait *u; int *i} *)
702 and wait (union wait *) to be compatible. */
703 if (TREE_CODE (TREE_VALUE (args1
)) == UNION_TYPE
704 && (TYPE_NAME (TREE_VALUE (args1
)) == 0
705 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1
)))
706 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1
))) == INTEGER_CST
707 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1
)),
708 TYPE_SIZE (TREE_VALUE (args2
))))
711 for (memb
= TYPE_FIELDS (TREE_VALUE (args1
));
712 memb
; memb
= TREE_CHAIN (memb
))
713 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (args2
)))
718 else if (TREE_CODE (TREE_VALUE (args2
)) == UNION_TYPE
719 && (TYPE_NAME (TREE_VALUE (args2
)) == 0
720 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2
)))
721 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2
))) == INTEGER_CST
722 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2
)),
723 TYPE_SIZE (TREE_VALUE (args1
))))
726 for (memb
= TYPE_FIELDS (TREE_VALUE (args2
));
727 memb
; memb
= TREE_CHAIN (memb
))
728 if (comptypes (TREE_TYPE (memb
), TREE_VALUE (args1
)))
737 /* comptypes said ok, but record if it said to warn. */
741 args1
= TREE_CHAIN (args1
);
742 args2
= TREE_CHAIN (args2
);
746 /* Compute the size to increment a pointer by. */
749 c_size_in_bytes (type
)
752 enum tree_code code
= TREE_CODE (type
);
754 if (code
== FUNCTION_TYPE
|| code
== VOID_TYPE
|| code
== ERROR_MARK
)
755 return size_one_node
;
757 if (!COMPLETE_OR_VOID_TYPE_P (type
))
759 error ("arithmetic on pointer to an incomplete type");
760 return size_one_node
;
763 /* Convert in case a char is more than one unit. */
764 return size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
765 size_int (TYPE_PRECISION (char_type_node
)
769 /* Return either DECL or its known constant value (if it has one). */
772 decl_constant_value (decl
)
775 if (/* Don't change a variable array bound or initial value to a constant
776 in a place where a variable is invalid. */
777 current_function_decl
!= 0
778 && ! TREE_THIS_VOLATILE (decl
)
779 && TREE_READONLY (decl
)
780 && DECL_INITIAL (decl
) != 0
781 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
782 /* This is invalid if initial value is not constant.
783 If it has either a function call, a memory reference,
784 or a variable, then re-evaluating it could give different results. */
785 && TREE_CONSTANT (DECL_INITIAL (decl
))
786 /* Check for cases where this is sub-optimal, even though valid. */
787 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
788 return DECL_INITIAL (decl
);
792 /* Return either DECL or its known constant value (if it has one), but
793 return DECL if pedantic or DECL has mode BLKmode. This is for
794 bug-compatibility with the old behavior of decl_constant_value
795 (before GCC 3.0); every use of this function is a bug and it should
796 be removed before GCC 3.1. It is not appropriate to use pedantic
797 in a way that affects optimization, and BLKmode is probably not the
798 right test for avoiding misoptimizations either. */
801 decl_constant_value_for_broken_optimization (decl
)
804 if (pedantic
|| DECL_MODE (decl
) == BLKmode
)
807 return decl_constant_value (decl
);
811 /* Perform the default conversion of arrays and functions to pointers.
812 Return the result of converting EXP. For any other expression, just
816 default_function_array_conversion (exp
)
820 tree type
= TREE_TYPE (exp
);
821 enum tree_code code
= TREE_CODE (type
);
824 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
827 Do not use STRIP_NOPS here! It will remove conversions from pointer
828 to integer and cause infinite recursion. */
830 while (TREE_CODE (exp
) == NON_LVALUE_EXPR
831 || (TREE_CODE (exp
) == NOP_EXPR
832 && TREE_TYPE (TREE_OPERAND (exp
, 0)) == TREE_TYPE (exp
)))
834 if (TREE_CODE (exp
) == NON_LVALUE_EXPR
)
836 exp
= TREE_OPERAND (exp
, 0);
839 /* Preserve the original expression code. */
840 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp
))))
841 C_SET_EXP_ORIGINAL_CODE (exp
, C_EXP_ORIGINAL_CODE (orig_exp
));
843 if (code
== FUNCTION_TYPE
)
845 return build_unary_op (ADDR_EXPR
, exp
, 0);
847 if (code
== ARRAY_TYPE
)
850 tree restype
= TREE_TYPE (type
);
856 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r' || DECL_P (exp
))
858 constp
= TREE_READONLY (exp
);
859 volatilep
= TREE_THIS_VOLATILE (exp
);
862 if (TYPE_QUALS (type
) || constp
|| volatilep
)
864 = c_build_qualified_type (restype
,
866 | (constp
* TYPE_QUAL_CONST
)
867 | (volatilep
* TYPE_QUAL_VOLATILE
));
869 if (TREE_CODE (exp
) == INDIRECT_REF
)
870 return convert (TYPE_POINTER_TO (restype
),
871 TREE_OPERAND (exp
, 0));
873 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
875 tree op1
= default_conversion (TREE_OPERAND (exp
, 1));
876 return build (COMPOUND_EXPR
, TREE_TYPE (op1
),
877 TREE_OPERAND (exp
, 0), op1
);
880 lvalue_array_p
= !not_lvalue
&& lvalue_p (exp
);
881 if (!flag_isoc99
&& !lvalue_array_p
)
883 /* Before C99, non-lvalue arrays do not decay to pointers.
884 Normally, using such an array would be invalid; but it can
885 be used correctly inside sizeof or as a statement expression.
886 Thus, do not give an error here; an error will result later. */
890 ptrtype
= build_pointer_type (restype
);
892 if (TREE_CODE (exp
) == VAR_DECL
)
894 /* ??? This is not really quite correct
895 in that the type of the operand of ADDR_EXPR
896 is not the target type of the type of the ADDR_EXPR itself.
897 Question is, can this lossage be avoided? */
898 adr
= build1 (ADDR_EXPR
, ptrtype
, exp
);
899 if (!c_mark_addressable (exp
))
900 return error_mark_node
;
901 TREE_CONSTANT (adr
) = staticp (exp
);
902 TREE_SIDE_EFFECTS (adr
) = 0; /* Default would be, same as EXP. */
905 /* This way is better for a COMPONENT_REF since it can
906 simplify the offset for a component. */
907 adr
= build_unary_op (ADDR_EXPR
, exp
, 1);
908 return convert (ptrtype
, adr
);
913 /* Perform default promotions for C data used in expressions.
914 Arrays and functions are converted to pointers;
915 enumeral types or short or char, to int.
916 In addition, manifest constants symbols are replaced by their values. */
919 default_conversion (exp
)
923 tree type
= TREE_TYPE (exp
);
924 enum tree_code code
= TREE_CODE (type
);
926 if (code
== FUNCTION_TYPE
|| code
== ARRAY_TYPE
)
927 return default_function_array_conversion (exp
);
929 /* Constants can be used directly unless they're not loadable. */
930 if (TREE_CODE (exp
) == CONST_DECL
)
931 exp
= DECL_INITIAL (exp
);
933 /* Replace a nonvolatile const static variable with its value unless
934 it is an array, in which case we must be sure that taking the
935 address of the array produces consistent results. */
936 else if (optimize
&& TREE_CODE (exp
) == VAR_DECL
&& code
!= ARRAY_TYPE
)
938 exp
= decl_constant_value_for_broken_optimization (exp
);
939 type
= TREE_TYPE (exp
);
942 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
945 Do not use STRIP_NOPS here! It will remove conversions from pointer
946 to integer and cause infinite recursion. */
948 while (TREE_CODE (exp
) == NON_LVALUE_EXPR
949 || (TREE_CODE (exp
) == NOP_EXPR
950 && TREE_TYPE (TREE_OPERAND (exp
, 0)) == TREE_TYPE (exp
)))
951 exp
= TREE_OPERAND (exp
, 0);
953 /* Preserve the original expression code. */
954 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp
))))
955 C_SET_EXP_ORIGINAL_CODE (exp
, C_EXP_ORIGINAL_CODE (orig_exp
));
957 /* Normally convert enums to int,
958 but convert wide enums to something wider. */
959 if (code
== ENUMERAL_TYPE
)
961 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
962 TYPE_PRECISION (integer_type_node
)),
963 ((TYPE_PRECISION (type
)
964 >= TYPE_PRECISION (integer_type_node
))
965 && TREE_UNSIGNED (type
)));
967 return convert (type
, exp
);
970 if (TREE_CODE (exp
) == COMPONENT_REF
971 && DECL_C_BIT_FIELD (TREE_OPERAND (exp
, 1))
972 /* If it's thinner than an int, promote it like a
973 c_promoting_integer_type_p, otherwise leave it alone. */
974 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp
, 1)),
975 TYPE_PRECISION (integer_type_node
)))
976 return convert (integer_type_node
, exp
);
978 if (c_promoting_integer_type_p (type
))
980 /* Preserve unsignedness if not really getting any wider. */
981 if (TREE_UNSIGNED (type
)
982 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
983 return convert (unsigned_type_node
, exp
);
985 return convert (integer_type_node
, exp
);
988 if (code
== VOID_TYPE
)
990 error ("void value not ignored as it ought to be");
991 return error_mark_node
;
996 /* Look up COMPONENT in a structure or union DECL.
998 If the component name is not found, returns NULL_TREE. Otherwise,
999 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1000 stepping down the chain to the component, which is in the last
1001 TREE_VALUE of the list. Normally the list is of length one, but if
1002 the component is embedded within (nested) anonymous structures or
1003 unions, the list steps down the chain to the component. */
1006 lookup_field (decl
, component
)
1007 tree decl
, component
;
1009 tree type
= TREE_TYPE (decl
);
1012 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1013 to the field elements. Use a binary search on this array to quickly
1014 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1015 will always be set for structures which have many elements. */
1017 if (TYPE_LANG_SPECIFIC (type
))
1020 tree
*field_array
= &TYPE_LANG_SPECIFIC (type
)->elts
[0];
1022 field
= TYPE_FIELDS (type
);
1024 top
= TYPE_LANG_SPECIFIC (type
)->len
;
1025 while (top
- bot
> 1)
1027 half
= (top
- bot
+ 1) >> 1;
1028 field
= field_array
[bot
+half
];
1030 if (DECL_NAME (field
) == NULL_TREE
)
1032 /* Step through all anon unions in linear fashion. */
1033 while (DECL_NAME (field_array
[bot
]) == NULL_TREE
)
1035 field
= field_array
[bot
++];
1036 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
1037 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
1039 tree anon
= lookup_field (field
, component
);
1042 return tree_cons (NULL_TREE
, field
, anon
);
1046 /* Entire record is only anon unions. */
1050 /* Restart the binary search, with new lower bound. */
1054 if (DECL_NAME (field
) == component
)
1056 if (DECL_NAME (field
) < component
)
1062 if (DECL_NAME (field_array
[bot
]) == component
)
1063 field
= field_array
[bot
];
1064 else if (DECL_NAME (field
) != component
)
1069 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1071 if (DECL_NAME (field
) == NULL_TREE
1072 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
1073 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
))
1075 tree anon
= lookup_field (field
, component
);
1078 return tree_cons (NULL_TREE
, field
, anon
);
1081 if (DECL_NAME (field
) == component
)
1085 if (field
== NULL_TREE
)
1089 return tree_cons (NULL_TREE
, field
, NULL_TREE
);
1092 /* Make an expression to refer to the COMPONENT field of
1093 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1096 build_component_ref (datum
, component
)
1097 tree datum
, component
;
1099 tree type
= TREE_TYPE (datum
);
1100 enum tree_code code
= TREE_CODE (type
);
1104 /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
1105 If pedantic ensure that the arguments are not lvalues; otherwise,
1106 if the component is an array, it would wrongly decay to a pointer in
1108 We cannot do this with a COND_EXPR, because in a conditional expression
1109 the default promotions are applied to both sides, and this would yield
1110 the wrong type of the result; for example, if the components have
1112 switch (TREE_CODE (datum
))
1116 tree value
= build_component_ref (TREE_OPERAND (datum
, 1), component
);
1117 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1118 TREE_OPERAND (datum
, 0), pedantic_non_lvalue (value
));
1124 /* See if there is a field or component with name COMPONENT. */
1126 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
1128 if (!COMPLETE_TYPE_P (type
))
1130 c_incomplete_type_error (NULL_TREE
, type
);
1131 return error_mark_node
;
1134 field
= lookup_field (datum
, component
);
1138 error ("%s has no member named `%s'",
1139 code
== RECORD_TYPE
? "structure" : "union",
1140 IDENTIFIER_POINTER (component
));
1141 return error_mark_node
;
1144 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1145 This might be better solved in future the way the C++ front
1146 end does it - by giving the anonymous entities each a
1147 separate name and type, and then have build_component_ref
1148 recursively call itself. We can't do that here. */
1149 for (; field
; field
= TREE_CHAIN (field
))
1151 tree subdatum
= TREE_VALUE (field
);
1153 if (TREE_TYPE (subdatum
) == error_mark_node
)
1154 return error_mark_node
;
1156 ref
= build (COMPONENT_REF
, TREE_TYPE (subdatum
), datum
, subdatum
);
1157 if (TREE_READONLY (datum
) || TREE_READONLY (subdatum
))
1158 TREE_READONLY (ref
) = 1;
1159 if (TREE_THIS_VOLATILE (datum
) || TREE_THIS_VOLATILE (subdatum
))
1160 TREE_THIS_VOLATILE (ref
) = 1;
1162 if (TREE_DEPRECATED (subdatum
))
1163 warn_deprecated_use (subdatum
);
1170 else if (code
!= ERROR_MARK
)
1171 error ("request for member `%s' in something not a structure or union",
1172 IDENTIFIER_POINTER (component
));
1174 return error_mark_node
;
1177 /* Given an expression PTR for a pointer, return an expression
1178 for the value pointed to.
1179 ERRORSTRING is the name of the operator to appear in error messages. */
1182 build_indirect_ref (ptr
, errorstring
)
1184 const char *errorstring
;
1186 tree pointer
= default_conversion (ptr
);
1187 tree type
= TREE_TYPE (pointer
);
1189 if (TREE_CODE (type
) == POINTER_TYPE
)
1191 if (TREE_CODE (pointer
) == ADDR_EXPR
1193 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
1194 == TREE_TYPE (type
)))
1195 return TREE_OPERAND (pointer
, 0);
1198 tree t
= TREE_TYPE (type
);
1199 tree ref
= build1 (INDIRECT_REF
, TYPE_MAIN_VARIANT (t
), pointer
);
1201 if (!COMPLETE_OR_VOID_TYPE_P (t
) && TREE_CODE (t
) != ARRAY_TYPE
)
1203 error ("dereferencing pointer to incomplete type");
1204 return error_mark_node
;
1206 if (VOID_TYPE_P (t
) && skip_evaluation
== 0)
1207 warning ("dereferencing `void *' pointer");
1209 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1210 so that we get the proper error message if the result is used
1211 to assign to. Also, &* is supposed to be a no-op.
1212 And ANSI C seems to specify that the type of the result
1213 should be the const type. */
1214 /* A de-reference of a pointer to const is not a const. It is valid
1215 to change it via some other pointer. */
1216 TREE_READONLY (ref
) = TYPE_READONLY (t
);
1217 TREE_SIDE_EFFECTS (ref
)
1218 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
) || flag_volatile
;
1219 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
1223 else if (TREE_CODE (pointer
) != ERROR_MARK
)
1224 error ("invalid type argument of `%s'", errorstring
);
1225 return error_mark_node
;
1228 /* This handles expressions of the form "a[i]", which denotes
1231 This is logically equivalent in C to *(a+i), but we may do it differently.
1232 If A is a variable or a member, we generate a primitive ARRAY_REF.
1233 This avoids forcing the array out of registers, and can work on
1234 arrays that are not lvalues (for example, members of structures returned
1238 build_array_ref (array
, index
)
1243 error ("subscript missing in array reference");
1244 return error_mark_node
;
1247 if (TREE_TYPE (array
) == error_mark_node
1248 || TREE_TYPE (index
) == error_mark_node
)
1249 return error_mark_node
;
1251 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
1252 && TREE_CODE (array
) != INDIRECT_REF
)
1256 /* Subscripting with type char is likely to lose
1257 on a machine where chars are signed.
1258 So warn on any machine, but optionally.
1259 Don't warn for unsigned char since that type is safe.
1260 Don't warn for signed char because anyone who uses that
1261 must have done so deliberately. */
1262 if (warn_char_subscripts
1263 && TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
)
1264 warning ("array subscript has type `char'");
1266 /* Apply default promotions *after* noticing character types. */
1267 index
= default_conversion (index
);
1269 /* Require integer *after* promotion, for sake of enums. */
1270 if (TREE_CODE (TREE_TYPE (index
)) != INTEGER_TYPE
)
1272 error ("array subscript is not an integer");
1273 return error_mark_node
;
1276 /* An array that is indexed by a non-constant
1277 cannot be stored in a register; we must be able to do
1278 address arithmetic on its address.
1279 Likewise an array of elements of variable size. */
1280 if (TREE_CODE (index
) != INTEGER_CST
1281 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
1282 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
1284 if (!c_mark_addressable (array
))
1285 return error_mark_node
;
1287 /* An array that is indexed by a constant value which is not within
1288 the array bounds cannot be stored in a register either; because we
1289 would get a crash in store_bit_field/extract_bit_field when trying
1290 to access a non-existent part of the register. */
1291 if (TREE_CODE (index
) == INTEGER_CST
1292 && TYPE_VALUES (TREE_TYPE (array
))
1293 && ! int_fits_type_p (index
, TYPE_VALUES (TREE_TYPE (array
))))
1295 if (!c_mark_addressable (array
))
1296 return error_mark_node
;
1302 while (TREE_CODE (foo
) == COMPONENT_REF
)
1303 foo
= TREE_OPERAND (foo
, 0);
1304 if (TREE_CODE (foo
) == VAR_DECL
&& DECL_REGISTER (foo
))
1305 pedwarn ("ISO C forbids subscripting `register' array");
1306 else if (! flag_isoc99
&& ! lvalue_p (foo
))
1307 pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1310 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array
)));
1311 rval
= build (ARRAY_REF
, type
, array
, index
);
1312 /* Array ref is const/volatile if the array elements are
1313 or if the array is. */
1314 TREE_READONLY (rval
)
1315 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
1316 | TREE_READONLY (array
));
1317 TREE_SIDE_EFFECTS (rval
)
1318 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1319 | TREE_SIDE_EFFECTS (array
));
1320 TREE_THIS_VOLATILE (rval
)
1321 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
1322 /* This was added by rms on 16 Nov 91.
1323 It fixes vol struct foo *a; a->elts[1]
1324 in an inline function.
1325 Hope it doesn't break something else. */
1326 | TREE_THIS_VOLATILE (array
));
1327 return require_complete_type (fold (rval
));
1331 tree ar
= default_conversion (array
);
1332 tree ind
= default_conversion (index
);
1334 /* Do the same warning check as above, but only on the part that's
1335 syntactically the index and only if it is also semantically
1337 if (warn_char_subscripts
1338 && TREE_CODE (TREE_TYPE (index
)) == INTEGER_TYPE
1339 && TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
)
1340 warning ("subscript has type `char'");
1342 /* Put the integer in IND to simplify error checking. */
1343 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
1350 if (ar
== error_mark_node
)
1353 if (TREE_CODE (TREE_TYPE (ar
)) != POINTER_TYPE
1354 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar
))) == FUNCTION_TYPE
)
1356 error ("subscripted value is neither array nor pointer");
1357 return error_mark_node
;
1359 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
1361 error ("array subscript is not an integer");
1362 return error_mark_node
;
1365 return build_indirect_ref (build_binary_op (PLUS_EXPR
, ar
, ind
, 0),
1370 /* Build an external reference to identifier ID. FUN indicates
1371 whether this will be used for a function call. */
1373 build_external_ref (id
, fun
)
1378 tree decl
= lookup_name (id
);
1379 tree objc_ivar
= lookup_objc_ivar (id
);
1381 if (decl
&& TREE_DEPRECATED (decl
))
1382 warn_deprecated_use (decl
);
1384 if (!decl
|| decl
== error_mark_node
|| C_DECL_ANTICIPATED (decl
))
1390 if (!decl
|| decl
== error_mark_node
)
1391 /* Ordinary implicit function declaration. */
1392 ref
= implicitly_declare (id
);
1395 /* Implicit declaration of built-in function. Don't
1396 change the built-in declaration, but don't let this
1397 go by silently, either. */
1398 implicit_decl_warning (id
);
1400 /* only issue this warning once */
1401 C_DECL_ANTICIPATED (decl
) = 0;
1407 /* Reference to undeclared variable, including reference to
1408 builtin outside of function-call context. */
1409 if (current_function_decl
== 0)
1410 error ("`%s' undeclared here (not in a function)",
1411 IDENTIFIER_POINTER (id
));
1414 if (IDENTIFIER_GLOBAL_VALUE (id
) != error_mark_node
1415 || IDENTIFIER_ERROR_LOCUS (id
) != current_function_decl
)
1417 error ("`%s' undeclared (first use in this function)",
1418 IDENTIFIER_POINTER (id
));
1420 if (! undeclared_variable_notice
)
1422 error ("(Each undeclared identifier is reported only once");
1423 error ("for each function it appears in.)");
1424 undeclared_variable_notice
= 1;
1427 IDENTIFIER_GLOBAL_VALUE (id
) = error_mark_node
;
1428 IDENTIFIER_ERROR_LOCUS (id
) = current_function_decl
;
1430 return error_mark_node
;
1435 /* Properly declared variable or function reference. */
1438 else if (decl
!= objc_ivar
&& IDENTIFIER_LOCAL_VALUE (id
))
1440 warning ("local declaration of `%s' hides instance variable",
1441 IDENTIFIER_POINTER (id
));
1448 if (TREE_TYPE (ref
) == error_mark_node
)
1449 return error_mark_node
;
1451 if (!skip_evaluation
)
1452 assemble_external (ref
);
1453 TREE_USED (ref
) = 1;
1455 if (TREE_CODE (ref
) == CONST_DECL
)
1457 ref
= DECL_INITIAL (ref
);
1458 TREE_CONSTANT (ref
) = 1;
1464 /* Build a function call to function FUNCTION with parameters PARAMS.
1465 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1466 TREE_VALUE of each node is a parameter-expression.
1467 FUNCTION's data type may be a function type or a pointer-to-function. */
1470 build_function_call (function
, params
)
1471 tree function
, params
;
1473 tree fntype
, fundecl
= 0;
1474 tree coerced_params
;
1475 tree name
= NULL_TREE
, result
;
1477 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1478 STRIP_TYPE_NOPS (function
);
1480 /* Convert anything with function type to a pointer-to-function. */
1481 if (TREE_CODE (function
) == FUNCTION_DECL
)
1483 name
= DECL_NAME (function
);
1485 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1486 (because calling an inline function does not mean the function
1487 needs to be separately compiled). */
1488 fntype
= build_type_variant (TREE_TYPE (function
),
1489 TREE_READONLY (function
),
1490 TREE_THIS_VOLATILE (function
));
1492 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
1495 function
= default_conversion (function
);
1497 fntype
= TREE_TYPE (function
);
1499 if (TREE_CODE (fntype
) == ERROR_MARK
)
1500 return error_mark_node
;
1502 if (!(TREE_CODE (fntype
) == POINTER_TYPE
1503 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
1505 error ("called object is not a function");
1506 return error_mark_node
;
1509 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
1510 current_function_returns_abnormally
= 1;
1512 /* fntype now gets the type of function pointed to. */
1513 fntype
= TREE_TYPE (fntype
);
1515 /* Convert the parameters to the types declared in the
1516 function prototype, or apply default promotions. */
1519 = convert_arguments (TYPE_ARG_TYPES (fntype
), params
, name
, fundecl
);
1521 /* Check that the arguments to the function are valid. */
1523 check_function_arguments (TYPE_ATTRIBUTES (fntype
), coerced_params
);
1525 /* Recognize certain built-in functions so we can make tree-codes
1526 other than CALL_EXPR. We do this when it enables fold-const.c
1527 to do something useful. */
1529 if (TREE_CODE (function
) == ADDR_EXPR
1530 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
1531 && DECL_BUILT_IN (TREE_OPERAND (function
, 0)))
1533 result
= expand_tree_builtin (TREE_OPERAND (function
, 0),
1534 params
, coerced_params
);
1539 result
= build (CALL_EXPR
, TREE_TYPE (fntype
),
1540 function
, coerced_params
, NULL_TREE
);
1541 TREE_SIDE_EFFECTS (result
) = 1;
1542 result
= fold (result
);
1544 if (VOID_TYPE_P (TREE_TYPE (result
)))
1546 return require_complete_type (result
);
1549 /* Convert the argument expressions in the list VALUES
1550 to the types in the list TYPELIST. The result is a list of converted
1551 argument expressions.
1553 If TYPELIST is exhausted, or when an element has NULL as its type,
1554 perform the default conversions.
1556 PARMLIST is the chain of parm decls for the function being called.
1557 It may be 0, if that info is not available.
1558 It is used only for generating error messages.
1560 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1562 This is also where warnings about wrong number of args are generated.
1564 Both VALUES and the returned value are chains of TREE_LIST nodes
1565 with the elements of the list in the TREE_VALUE slots of those nodes. */
1568 convert_arguments (typelist
, values
, name
, fundecl
)
1569 tree typelist
, values
, name
, fundecl
;
1571 tree typetail
, valtail
;
1575 /* Scan the given expressions and types, producing individual
1576 converted arguments and pushing them on RESULT in reverse order. */
1578 for (valtail
= values
, typetail
= typelist
, parmnum
= 0;
1580 valtail
= TREE_CHAIN (valtail
), parmnum
++)
1582 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
1583 tree val
= TREE_VALUE (valtail
);
1585 if (type
== void_type_node
)
1588 error ("too many arguments to function `%s'",
1589 IDENTIFIER_POINTER (name
));
1591 error ("too many arguments to function");
1595 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1596 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1597 to convert automatically to a pointer. */
1598 if (TREE_CODE (val
) == NON_LVALUE_EXPR
)
1599 val
= TREE_OPERAND (val
, 0);
1601 val
= default_function_array_conversion (val
);
1603 val
= require_complete_type (val
);
1607 /* Formal parm type is specified by a function prototype. */
1610 if (!COMPLETE_TYPE_P (type
))
1612 error ("type of formal parameter %d is incomplete", parmnum
+ 1);
1617 /* Optionally warn about conversions that
1618 differ from the default conversions. */
1619 if (warn_conversion
|| warn_traditional
)
1621 int formal_prec
= TYPE_PRECISION (type
);
1623 if (INTEGRAL_TYPE_P (type
)
1624 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
1625 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name
, parmnum
+ 1);
1626 if (INTEGRAL_TYPE_P (type
)
1627 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
1628 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name
, parmnum
+ 1);
1629 else if (TREE_CODE (type
) == COMPLEX_TYPE
1630 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
1631 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name
, parmnum
+ 1);
1632 else if (TREE_CODE (type
) == REAL_TYPE
1633 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
1634 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name
, parmnum
+ 1);
1635 else if (TREE_CODE (type
) == COMPLEX_TYPE
1636 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
1637 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name
, parmnum
+ 1);
1638 else if (TREE_CODE (type
) == REAL_TYPE
1639 && TREE_CODE (TREE_TYPE (val
)) == COMPLEX_TYPE
)
1640 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name
, parmnum
+ 1);
1641 /* ??? At some point, messages should be written about
1642 conversions between complex types, but that's too messy
1644 else if (TREE_CODE (type
) == REAL_TYPE
1645 && TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
)
1647 /* Warn if any argument is passed as `float',
1648 since without a prototype it would be `double'. */
1649 if (formal_prec
== TYPE_PRECISION (float_type_node
))
1650 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name
, parmnum
+ 1);
1652 /* Detect integer changing in width or signedness.
1653 These warnings are only activated with
1654 -Wconversion, not with -Wtraditional. */
1655 else if (warn_conversion
&& INTEGRAL_TYPE_P (type
)
1656 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
1658 tree would_have_been
= default_conversion (val
);
1659 tree type1
= TREE_TYPE (would_have_been
);
1661 if (TREE_CODE (type
) == ENUMERAL_TYPE
1662 && (TYPE_MAIN_VARIANT (type
)
1663 == TYPE_MAIN_VARIANT (TREE_TYPE (val
))))
1664 /* No warning if function asks for enum
1665 and the actual arg is that enum type. */
1667 else if (formal_prec
!= TYPE_PRECISION (type1
))
1668 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name
, parmnum
+ 1);
1669 else if (TREE_UNSIGNED (type
) == TREE_UNSIGNED (type1
))
1671 /* Don't complain if the formal parameter type
1672 is an enum, because we can't tell now whether
1673 the value was an enum--even the same enum. */
1674 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1676 else if (TREE_CODE (val
) == INTEGER_CST
1677 && int_fits_type_p (val
, type
))
1678 /* Change in signedness doesn't matter
1679 if a constant value is unaffected. */
1681 /* Likewise for a constant in a NOP_EXPR. */
1682 else if (TREE_CODE (val
) == NOP_EXPR
1683 && TREE_CODE (TREE_OPERAND (val
, 0)) == INTEGER_CST
1684 && int_fits_type_p (TREE_OPERAND (val
, 0), type
))
1686 #if 0 /* We never get such tree structure here. */
1687 else if (TREE_CODE (TREE_TYPE (val
)) == ENUMERAL_TYPE
1688 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val
)), type
)
1689 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val
)), type
))
1690 /* Change in signedness doesn't matter
1691 if an enum value is unaffected. */
1694 /* If the value is extended from a narrower
1695 unsigned type, it doesn't matter whether we
1696 pass it as signed or unsigned; the value
1697 certainly is the same either way. */
1698 else if (TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
)
1699 && TREE_UNSIGNED (TREE_TYPE (val
)))
1701 else if (TREE_UNSIGNED (type
))
1702 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name
, parmnum
+ 1);
1704 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name
, parmnum
+ 1);
1708 parmval
= convert_for_assignment (type
, val
,
1709 (char *) 0, /* arg passing */
1710 fundecl
, name
, parmnum
+ 1);
1712 if (PROMOTE_PROTOTYPES
1713 && INTEGRAL_TYPE_P (type
)
1714 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
1715 parmval
= default_conversion (parmval
);
1717 result
= tree_cons (NULL_TREE
, parmval
, result
);
1719 else if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
1720 && (TYPE_PRECISION (TREE_TYPE (val
))
1721 < TYPE_PRECISION (double_type_node
)))
1722 /* Convert `float' to `double'. */
1723 result
= tree_cons (NULL_TREE
, convert (double_type_node
, val
), result
);
1725 /* Convert `short' and `char' to full-size `int'. */
1726 result
= tree_cons (NULL_TREE
, default_conversion (val
), result
);
1729 typetail
= TREE_CHAIN (typetail
);
1732 if (typetail
!= 0 && TREE_VALUE (typetail
) != void_type_node
)
1735 error ("too few arguments to function `%s'",
1736 IDENTIFIER_POINTER (name
));
1738 error ("too few arguments to function");
1741 return nreverse (result
);
1744 /* This is the entry point used by the parser
1745 for binary operators in the input.
1746 In addition to constructing the expression,
1747 we check for operands that were written with other binary operators
1748 in a way that is likely to confuse the user. */
1751 parser_build_binary_op (code
, arg1
, arg2
)
1752 enum tree_code code
;
1755 tree result
= build_binary_op (code
, arg1
, arg2
, 1);
1758 char class1
= TREE_CODE_CLASS (TREE_CODE (arg1
));
1759 char class2
= TREE_CODE_CLASS (TREE_CODE (arg2
));
1760 enum tree_code code1
= ERROR_MARK
;
1761 enum tree_code code2
= ERROR_MARK
;
1763 if (TREE_CODE (result
) == ERROR_MARK
)
1764 return error_mark_node
;
1766 if (IS_EXPR_CODE_CLASS (class1
))
1767 code1
= C_EXP_ORIGINAL_CODE (arg1
);
1768 if (IS_EXPR_CODE_CLASS (class2
))
1769 code2
= C_EXP_ORIGINAL_CODE (arg2
);
1771 /* Check for cases such as x+y<<z which users are likely
1772 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1773 is cleared to prevent these warnings. */
1774 if (warn_parentheses
)
1776 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
1778 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
1779 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
1780 warning ("suggest parentheses around + or - inside shift");
1783 if (code
== TRUTH_ORIF_EXPR
)
1785 if (code1
== TRUTH_ANDIF_EXPR
1786 || code2
== TRUTH_ANDIF_EXPR
)
1787 warning ("suggest parentheses around && within ||");
1790 if (code
== BIT_IOR_EXPR
)
1792 if (code1
== BIT_AND_EXPR
|| code1
== BIT_XOR_EXPR
1793 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
1794 || code2
== BIT_AND_EXPR
|| code2
== BIT_XOR_EXPR
1795 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
1796 warning ("suggest parentheses around arithmetic in operand of |");
1797 /* Check cases like x|y==z */
1798 if (TREE_CODE_CLASS (code1
) == '<' || TREE_CODE_CLASS (code2
) == '<')
1799 warning ("suggest parentheses around comparison in operand of |");
1802 if (code
== BIT_XOR_EXPR
)
1804 if (code1
== BIT_AND_EXPR
1805 || code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
1806 || code2
== BIT_AND_EXPR
1807 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
1808 warning ("suggest parentheses around arithmetic in operand of ^");
1809 /* Check cases like x^y==z */
1810 if (TREE_CODE_CLASS (code1
) == '<' || TREE_CODE_CLASS (code2
) == '<')
1811 warning ("suggest parentheses around comparison in operand of ^");
1814 if (code
== BIT_AND_EXPR
)
1816 if (code1
== PLUS_EXPR
|| code1
== MINUS_EXPR
1817 || code2
== PLUS_EXPR
|| code2
== MINUS_EXPR
)
1818 warning ("suggest parentheses around + or - in operand of &");
1819 /* Check cases like x&y==z */
1820 if (TREE_CODE_CLASS (code1
) == '<' || TREE_CODE_CLASS (code2
) == '<')
1821 warning ("suggest parentheses around comparison in operand of &");
1825 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1826 if (TREE_CODE_CLASS (code
) == '<' && extra_warnings
1827 && (TREE_CODE_CLASS (code1
) == '<' || TREE_CODE_CLASS (code2
) == '<'))
1828 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1830 unsigned_conversion_warning (result
, arg1
);
1831 unsigned_conversion_warning (result
, arg2
);
1832 overflow_warning (result
);
1834 class = TREE_CODE_CLASS (TREE_CODE (result
));
1836 /* Record the code that was specified in the source,
1837 for the sake of warnings about confusing nesting. */
1838 if (IS_EXPR_CODE_CLASS (class))
1839 C_SET_EXP_ORIGINAL_CODE (result
, code
);
1842 int flag
= TREE_CONSTANT (result
);
1843 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1844 so that convert_for_assignment wouldn't strip it.
1845 That way, we got warnings for things like p = (1 - 1).
1846 But it turns out we should not get those warnings. */
1847 result
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (result
), result
);
1848 C_SET_EXP_ORIGINAL_CODE (result
, code
);
1849 TREE_CONSTANT (result
) = flag
;
1855 /* Build a binary-operation expression without default conversions.
1856 CODE is the kind of expression to build.
1857 This function differs from `build' in several ways:
1858 the data type of the result is computed and recorded in it,
1859 warnings are generated if arg data types are invalid,
1860 special handling for addition and subtraction of pointers is known,
1861 and some optimization is done (operations on narrow ints
1862 are done in the narrower type when that gives the same result).
1863 Constant folding is also done before the result is returned.
1865 Note that the operands will never have enumeral types, or function
1866 or array types, because either they will have the default conversions
1867 performed or they have both just been converted to some other type in which
1868 the arithmetic is to be done. */
1871 build_binary_op (code
, orig_op0
, orig_op1
, convert_p
)
1872 enum tree_code code
;
1873 tree orig_op0
, orig_op1
;
1877 enum tree_code code0
, code1
;
1880 /* Expression code to give to the expression when it is built.
1881 Normally this is CODE, which is what the caller asked for,
1882 but in some special cases we change it. */
1883 enum tree_code resultcode
= code
;
1885 /* Data type in which the computation is to be performed.
1886 In the simplest cases this is the common type of the arguments. */
1887 tree result_type
= NULL
;
1889 /* Nonzero means operands have already been type-converted
1890 in whatever way is necessary.
1891 Zero means they need to be converted to RESULT_TYPE. */
1894 /* Nonzero means create the expression with this type, rather than
1896 tree build_type
= 0;
1898 /* Nonzero means after finally constructing the expression
1899 convert it to this type. */
1900 tree final_type
= 0;
1902 /* Nonzero if this is an operation like MIN or MAX which can
1903 safely be computed in short if both args are promoted shorts.
1904 Also implies COMMON.
1905 -1 indicates a bitwise operation; this makes a difference
1906 in the exact conditions for when it is safe to do the operation
1907 in a narrower mode. */
1910 /* Nonzero if this is a comparison operation;
1911 if both args are promoted shorts, compare the original shorts.
1912 Also implies COMMON. */
1913 int short_compare
= 0;
1915 /* Nonzero if this is a right-shift operation, which can be computed on the
1916 original short and then promoted if the operand is a promoted short. */
1917 int short_shift
= 0;
1919 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1924 op0
= default_conversion (orig_op0
);
1925 op1
= default_conversion (orig_op1
);
1933 type0
= TREE_TYPE (op0
);
1934 type1
= TREE_TYPE (op1
);
1936 /* The expression codes of the data types of the arguments tell us
1937 whether the arguments are integers, floating, pointers, etc. */
1938 code0
= TREE_CODE (type0
);
1939 code1
= TREE_CODE (type1
);
1941 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1942 STRIP_TYPE_NOPS (op0
);
1943 STRIP_TYPE_NOPS (op1
);
1945 /* If an error was already reported for one of the arguments,
1946 avoid reporting another error. */
1948 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
1949 return error_mark_node
;
1954 /* Handle the pointer + int case. */
1955 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
1956 return pointer_int_sum (PLUS_EXPR
, op0
, op1
);
1957 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
1958 return pointer_int_sum (PLUS_EXPR
, op1
, op0
);
1964 /* Subtraction of two similar pointers.
1965 We must subtract them as integers, then divide by object size. */
1966 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
1967 && comp_target_types (type0
, type1
, 1))
1968 return pointer_diff (op0
, op1
);
1969 /* Handle pointer minus int. Just like pointer plus int. */
1970 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
1971 return pointer_int_sum (MINUS_EXPR
, op0
, op1
);
1980 case TRUNC_DIV_EXPR
:
1982 case FLOOR_DIV_EXPR
:
1983 case ROUND_DIV_EXPR
:
1984 case EXACT_DIV_EXPR
:
1985 /* Floating point division by zero is a legitimate way to obtain
1986 infinities and NaNs. */
1987 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
1988 warning ("division by zero");
1990 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
1991 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
1992 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
1993 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
1995 if (!(code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
))
1996 resultcode
= RDIV_EXPR
;
1998 /* Although it would be tempting to shorten always here, that
1999 loses on some targets, since the modulo instruction is
2000 undefined if the quotient can't be represented in the
2001 computation mode. We shorten only if unsigned or if
2002 dividing by something we know != -1. */
2003 shorten
= (TREE_UNSIGNED (TREE_TYPE (orig_op0
))
2004 || (TREE_CODE (op1
) == INTEGER_CST
2005 && ! integer_all_onesp (op1
)));
2011 case BIT_ANDTC_EXPR
:
2014 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2016 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
2020 case TRUNC_MOD_EXPR
:
2021 case FLOOR_MOD_EXPR
:
2022 if (warn_div_by_zero
&& skip_evaluation
== 0 && integer_zerop (op1
))
2023 warning ("division by zero");
2025 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2027 /* Although it would be tempting to shorten always here, that loses
2028 on some targets, since the modulo instruction is undefined if the
2029 quotient can't be represented in the computation mode. We shorten
2030 only if unsigned or if dividing by something we know != -1. */
2031 shorten
= (TREE_UNSIGNED (TREE_TYPE (orig_op0
))
2032 || (TREE_CODE (op1
) == INTEGER_CST
2033 && ! integer_all_onesp (op1
)));
2038 case TRUTH_ANDIF_EXPR
:
2039 case TRUTH_ORIF_EXPR
:
2040 case TRUTH_AND_EXPR
:
2042 case TRUTH_XOR_EXPR
:
2043 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
2044 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
)
2045 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
2046 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
2048 /* Result of these operations is always an int,
2049 but that does not mean the operands should be
2050 converted to ints! */
2051 result_type
= integer_type_node
;
2052 op0
= c_common_truthvalue_conversion (op0
);
2053 op1
= c_common_truthvalue_conversion (op1
);
2058 /* Shift operations: result has same type as first operand;
2059 always convert second operand to int.
2060 Also set SHORT_SHIFT if shifting rightward. */
2063 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2065 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
2067 if (tree_int_cst_sgn (op1
) < 0)
2068 warning ("right shift count is negative");
2071 if (! integer_zerop (op1
))
2074 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
2075 warning ("right shift count >= width of type");
2079 /* Use the type of the value to be shifted. */
2080 result_type
= type0
;
2081 /* Convert the shift-count to an integer, regardless of size
2082 of value being shifted. */
2083 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
2084 op1
= convert (integer_type_node
, op1
);
2085 /* Avoid converting op1 to result_type later. */
2091 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2093 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
2095 if (tree_int_cst_sgn (op1
) < 0)
2096 warning ("left shift count is negative");
2098 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
2099 warning ("left shift count >= width of type");
2102 /* Use the type of the value to be shifted. */
2103 result_type
= type0
;
2104 /* Convert the shift-count to an integer, regardless of size
2105 of value being shifted. */
2106 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
2107 op1
= convert (integer_type_node
, op1
);
2108 /* Avoid converting op1 to result_type later. */
2115 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
2117 if (TREE_CODE (op1
) == INTEGER_CST
&& skip_evaluation
== 0)
2119 if (tree_int_cst_sgn (op1
) < 0)
2120 warning ("shift count is negative");
2121 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
2122 warning ("shift count >= width of type");
2125 /* Use the type of the value to be shifted. */
2126 result_type
= type0
;
2127 /* Convert the shift-count to an integer, regardless of size
2128 of value being shifted. */
2129 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
2130 op1
= convert (integer_type_node
, op1
);
2131 /* Avoid converting op1 to result_type later. */
2138 if (warn_float_equal
&& (code0
== REAL_TYPE
|| code1
== REAL_TYPE
))
2139 warning ("comparing floating point with == or != is unsafe");
2140 /* Result of comparison is always int,
2141 but don't convert the args to int! */
2142 build_type
= integer_type_node
;
2143 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
2144 || code0
== COMPLEX_TYPE
2145 || code0
== VECTOR_TYPE
)
2146 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
2147 || code1
== COMPLEX_TYPE
2148 || code1
== VECTOR_TYPE
))
2150 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
2152 tree tt0
= TREE_TYPE (type0
);
2153 tree tt1
= TREE_TYPE (type1
);
2154 /* Anything compares with void *. void * compares with anything.
2155 Otherwise, the targets must be compatible
2156 and both must be object or both incomplete. */
2157 if (comp_target_types (type0
, type1
, 1))
2158 result_type
= common_type (type0
, type1
);
2159 else if (VOID_TYPE_P (tt0
))
2161 /* op0 != orig_op0 detects the case of something
2162 whose value is 0 but which isn't a valid null ptr const. */
2163 if (pedantic
&& (!integer_zerop (op0
) || op0
!= orig_op0
)
2164 && TREE_CODE (tt1
) == FUNCTION_TYPE
)
2165 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2167 else if (VOID_TYPE_P (tt1
))
2169 if (pedantic
&& (!integer_zerop (op1
) || op1
!= orig_op1
)
2170 && TREE_CODE (tt0
) == FUNCTION_TYPE
)
2171 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2174 pedwarn ("comparison of distinct pointer types lacks a cast");
2176 if (result_type
== NULL_TREE
)
2177 result_type
= ptr_type_node
;
2179 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
2180 && integer_zerop (op1
))
2181 result_type
= type0
;
2182 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
2183 && integer_zerop (op0
))
2184 result_type
= type1
;
2185 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2187 result_type
= type0
;
2188 pedwarn ("comparison between pointer and integer");
2190 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
2192 result_type
= type1
;
2193 pedwarn ("comparison between pointer and integer");
2199 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
2200 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
2202 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
2204 if (comp_target_types (type0
, type1
, 1))
2206 result_type
= common_type (type0
, type1
);
2208 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
2209 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2213 result_type
= ptr_type_node
;
2214 pedwarn ("comparison of distinct pointer types lacks a cast");
2223 build_type
= integer_type_node
;
2224 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
2225 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
2227 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
2229 if (comp_target_types (type0
, type1
, 1))
2231 result_type
= common_type (type0
, type1
);
2232 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
2233 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
2234 pedwarn ("comparison of complete and incomplete pointers");
2236 && TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
2237 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2241 result_type
= ptr_type_node
;
2242 pedwarn ("comparison of distinct pointer types lacks a cast");
2245 else if (code0
== POINTER_TYPE
&& TREE_CODE (op1
) == INTEGER_CST
2246 && integer_zerop (op1
))
2248 result_type
= type0
;
2249 if (pedantic
|| extra_warnings
)
2250 pedwarn ("ordered comparison of pointer with integer zero");
2252 else if (code1
== POINTER_TYPE
&& TREE_CODE (op0
) == INTEGER_CST
2253 && integer_zerop (op0
))
2255 result_type
= type1
;
2257 pedwarn ("ordered comparison of pointer with integer zero");
2259 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
2261 result_type
= type0
;
2262 pedwarn ("comparison between pointer and integer");
2264 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
2266 result_type
= type1
;
2267 pedwarn ("comparison between pointer and integer");
2271 case UNORDERED_EXPR
:
2278 build_type
= integer_type_node
;
2279 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
2281 error ("unordered comparison on non-floating point argument");
2282 return error_mark_node
;
2291 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
2292 || code0
== VECTOR_TYPE
)
2294 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
2295 || code1
== VECTOR_TYPE
))
2297 int none_complex
= (code0
!= COMPLEX_TYPE
&& code1
!= COMPLEX_TYPE
);
2299 if (shorten
|| common
|| short_compare
)
2300 result_type
= common_type (type0
, type1
);
2302 /* For certain operations (which identify themselves by shorten != 0)
2303 if both args were extended from the same smaller type,
2304 do the arithmetic in that type and then extend.
2306 shorten !=0 and !=1 indicates a bitwise operation.
2307 For them, this optimization is safe only if
2308 both args are zero-extended or both are sign-extended.
2309 Otherwise, we might change the result.
2310 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2311 but calculated in (unsigned short) it would be (unsigned short)-1. */
2313 if (shorten
&& none_complex
)
2315 int unsigned0
, unsigned1
;
2316 tree arg0
= get_narrower (op0
, &unsigned0
);
2317 tree arg1
= get_narrower (op1
, &unsigned1
);
2318 /* UNS is 1 if the operation to be done is an unsigned one. */
2319 int uns
= TREE_UNSIGNED (result_type
);
2322 final_type
= result_type
;
2324 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2325 but it *requires* conversion to FINAL_TYPE. */
2327 if ((TYPE_PRECISION (TREE_TYPE (op0
))
2328 == TYPE_PRECISION (TREE_TYPE (arg0
)))
2329 && TREE_TYPE (op0
) != final_type
)
2330 unsigned0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2331 if ((TYPE_PRECISION (TREE_TYPE (op1
))
2332 == TYPE_PRECISION (TREE_TYPE (arg1
)))
2333 && TREE_TYPE (op1
) != final_type
)
2334 unsigned1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2336 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2338 /* For bitwise operations, signedness of nominal type
2339 does not matter. Consider only how operands were extended. */
2343 /* Note that in all three cases below we refrain from optimizing
2344 an unsigned operation on sign-extended args.
2345 That would not be valid. */
2347 /* Both args variable: if both extended in same way
2348 from same width, do it in that width.
2349 Do it unsigned if args were zero-extended. */
2350 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
2351 < TYPE_PRECISION (result_type
))
2352 && (TYPE_PRECISION (TREE_TYPE (arg1
))
2353 == TYPE_PRECISION (TREE_TYPE (arg0
)))
2354 && unsigned0
== unsigned1
2355 && (unsigned0
|| !uns
))
2357 = c_common_signed_or_unsigned_type
2358 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
2359 else if (TREE_CODE (arg0
) == INTEGER_CST
2360 && (unsigned1
|| !uns
)
2361 && (TYPE_PRECISION (TREE_TYPE (arg1
))
2362 < TYPE_PRECISION (result_type
))
2364 = c_common_signed_or_unsigned_type (unsigned1
,
2366 int_fits_type_p (arg0
, type
)))
2368 else if (TREE_CODE (arg1
) == INTEGER_CST
2369 && (unsigned0
|| !uns
)
2370 && (TYPE_PRECISION (TREE_TYPE (arg0
))
2371 < TYPE_PRECISION (result_type
))
2373 = c_common_signed_or_unsigned_type (unsigned0
,
2375 int_fits_type_p (arg1
, type
)))
2379 /* Shifts can be shortened if shifting right. */
2384 tree arg0
= get_narrower (op0
, &unsigned_arg
);
2386 final_type
= result_type
;
2388 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
2389 unsigned_arg
= TREE_UNSIGNED (TREE_TYPE (op0
));
2391 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
2392 /* We can shorten only if the shift count is less than the
2393 number of bits in the smaller type size. */
2394 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
2395 /* We cannot drop an unsigned shift after sign-extension. */
2396 && (!TREE_UNSIGNED (final_type
) || unsigned_arg
))
2398 /* Do an unsigned shift if the operand was zero-extended. */
2400 = c_common_signed_or_unsigned_type (unsigned_arg
,
2402 /* Convert value-to-be-shifted to that type. */
2403 if (TREE_TYPE (op0
) != result_type
)
2404 op0
= convert (result_type
, op0
);
2409 /* Comparison operations are shortened too but differently.
2410 They identify themselves by setting short_compare = 1. */
2414 /* Don't write &op0, etc., because that would prevent op0
2415 from being kept in a register.
2416 Instead, make copies of the our local variables and
2417 pass the copies by reference, then copy them back afterward. */
2418 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
2419 enum tree_code xresultcode
= resultcode
;
2421 = shorten_compare (&xop0
, &xop1
, &xresult_type
, &xresultcode
);
2426 op0
= xop0
, op1
= xop1
;
2428 resultcode
= xresultcode
;
2430 if ((warn_sign_compare
< 0 ? extra_warnings
: warn_sign_compare
!= 0)
2431 && skip_evaluation
== 0)
2433 int op0_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op0
));
2434 int op1_signed
= ! TREE_UNSIGNED (TREE_TYPE (orig_op1
));
2435 int unsignedp0
, unsignedp1
;
2436 tree primop0
= get_narrower (op0
, &unsignedp0
);
2437 tree primop1
= get_narrower (op1
, &unsignedp1
);
2441 STRIP_TYPE_NOPS (xop0
);
2442 STRIP_TYPE_NOPS (xop1
);
2444 /* Give warnings for comparisons between signed and unsigned
2445 quantities that may fail.
2447 Do the checking based on the original operand trees, so that
2448 casts will be considered, but default promotions won't be.
2450 Do not warn if the comparison is being done in a signed type,
2451 since the signed type will only be chosen if it can represent
2452 all the values of the unsigned type. */
2453 if (! TREE_UNSIGNED (result_type
))
2455 /* Do not warn if both operands are the same signedness. */
2456 else if (op0_signed
== op1_signed
)
2463 sop
= xop0
, uop
= xop1
;
2465 sop
= xop1
, uop
= xop0
;
2467 /* Do not warn if the signed quantity is an
2468 unsuffixed integer literal (or some static
2469 constant expression involving such literals or a
2470 conditional expression involving such literals)
2471 and it is non-negative. */
2472 if (c_tree_expr_nonnegative_p (sop
))
2474 /* Do not warn if the comparison is an equality operation,
2475 the unsigned quantity is an integral constant, and it
2476 would fit in the result if the result were signed. */
2477 else if (TREE_CODE (uop
) == INTEGER_CST
2478 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
2480 (uop
, c_common_signed_type (result_type
)))
2482 /* Do not warn if the unsigned quantity is an enumeration
2483 constant and its maximum value would fit in the result
2484 if the result were signed. */
2485 else if (TREE_CODE (uop
) == INTEGER_CST
2486 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
2488 (TYPE_MAX_VALUE (TREE_TYPE(uop
)),
2489 c_common_signed_type (result_type
)))
2492 warning ("comparison between signed and unsigned");
2495 /* Warn if two unsigned values are being compared in a size
2496 larger than their original size, and one (and only one) is the
2497 result of a `~' operator. This comparison will always fail.
2499 Also warn if one operand is a constant, and the constant
2500 does not have all bits set that are set in the ~ operand
2501 when it is extended. */
2503 if ((TREE_CODE (primop0
) == BIT_NOT_EXPR
)
2504 != (TREE_CODE (primop1
) == BIT_NOT_EXPR
))
2506 if (TREE_CODE (primop0
) == BIT_NOT_EXPR
)
2507 primop0
= get_narrower (TREE_OPERAND (primop0
, 0),
2510 primop1
= get_narrower (TREE_OPERAND (primop1
, 0),
2513 if (host_integerp (primop0
, 0) || host_integerp (primop1
, 0))
2516 HOST_WIDE_INT constant
, mask
;
2517 int unsignedp
, bits
;
2519 if (host_integerp (primop0
, 0))
2522 unsignedp
= unsignedp1
;
2523 constant
= tree_low_cst (primop0
, 0);
2528 unsignedp
= unsignedp0
;
2529 constant
= tree_low_cst (primop1
, 0);
2532 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
2533 if (bits
< TYPE_PRECISION (result_type
)
2534 && bits
< HOST_BITS_PER_WIDE_INT
&& unsignedp
)
2536 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
2537 if ((mask
& constant
) != mask
)
2538 warning ("comparison of promoted ~unsigned with constant");
2541 else if (unsignedp0
&& unsignedp1
2542 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2543 < TYPE_PRECISION (result_type
))
2544 && (TYPE_PRECISION (TREE_TYPE (primop1
))
2545 < TYPE_PRECISION (result_type
)))
2546 warning ("comparison of promoted ~unsigned with unsigned");
2552 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2553 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2554 Then the expression will be built.
2555 It will be given type FINAL_TYPE if that is nonzero;
2556 otherwise, it will be given type RESULT_TYPE. */
2560 binary_op_error (code
);
2561 return error_mark_node
;
2566 if (TREE_TYPE (op0
) != result_type
)
2567 op0
= convert (result_type
, op0
);
2568 if (TREE_TYPE (op1
) != result_type
)
2569 op1
= convert (result_type
, op1
);
2572 if (build_type
== NULL_TREE
)
2573 build_type
= result_type
;
2576 tree result
= build (resultcode
, build_type
, op0
, op1
);
2579 folded
= fold (result
);
2580 if (folded
== result
)
2581 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
2582 if (final_type
!= 0)
2583 return convert (final_type
, folded
);
2589 /* Return true if `t' is known to be non-negative. */
2592 c_tree_expr_nonnegative_p (t
)
2595 if (TREE_CODE (t
) == STMT_EXPR
)
2597 t
=COMPOUND_BODY (STMT_EXPR_STMT (t
));
2599 /* Find the last statement in the chain, ignoring the final
2600 * scope statement */
2601 while (TREE_CHAIN (t
) != NULL_TREE
2602 && TREE_CODE (TREE_CHAIN (t
)) != SCOPE_STMT
)
2604 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0));
2606 return tree_expr_nonnegative_p (t
);
2609 /* Return a tree for the difference of pointers OP0 and OP1.
2610 The resulting tree has type int. */
2613 pointer_diff (op0
, op1
)
2616 tree result
, folded
;
2617 tree restype
= ptrdiff_type_node
;
2619 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
2620 tree con0
, con1
, lit0
, lit1
;
2621 tree orig_op1
= op1
;
2623 if (pedantic
|| warn_pointer_arith
)
2625 if (TREE_CODE (target_type
) == VOID_TYPE
)
2626 pedwarn ("pointer of type `void *' used in subtraction");
2627 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
2628 pedwarn ("pointer to a function used in subtraction");
2631 /* If the conversion to ptrdiff_type does anything like widening or
2632 converting a partial to an integral mode, we get a convert_expression
2633 that is in the way to do any simplifications.
2634 (fold-const.c doesn't know that the extra bits won't be needed.
2635 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2636 different mode in place.)
2637 So first try to find a common term here 'by hand'; we want to cover
2638 at least the cases that occur in legal static initializers. */
2639 con0
= TREE_CODE (op0
) == NOP_EXPR
? TREE_OPERAND (op0
, 0) : op0
;
2640 con1
= TREE_CODE (op1
) == NOP_EXPR
? TREE_OPERAND (op1
, 0) : op1
;
2642 if (TREE_CODE (con0
) == PLUS_EXPR
)
2644 lit0
= TREE_OPERAND (con0
, 1);
2645 con0
= TREE_OPERAND (con0
, 0);
2648 lit0
= integer_zero_node
;
2650 if (TREE_CODE (con1
) == PLUS_EXPR
)
2652 lit1
= TREE_OPERAND (con1
, 1);
2653 con1
= TREE_OPERAND (con1
, 0);
2656 lit1
= integer_zero_node
;
2658 if (operand_equal_p (con0
, con1
, 0))
2665 /* First do the subtraction as integers;
2666 then drop through to build the divide operator.
2667 Do not do default conversions on the minus operator
2668 in case restype is a short type. */
2670 op0
= build_binary_op (MINUS_EXPR
, convert (restype
, op0
),
2671 convert (restype
, op1
), 0);
2672 /* This generates an error if op1 is pointer to incomplete type. */
2673 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1
))))
2674 error ("arithmetic on pointer to an incomplete type");
2676 /* This generates an error if op0 is pointer to incomplete type. */
2677 op1
= c_size_in_bytes (target_type
);
2679 /* Divide by the size, in easiest possible way. */
2681 result
= build (EXACT_DIV_EXPR
, restype
, op0
, convert (restype
, op1
));
2683 folded
= fold (result
);
2684 if (folded
== result
)
2685 TREE_CONSTANT (folded
) = TREE_CONSTANT (op0
) & TREE_CONSTANT (op1
);
2689 /* Construct and perhaps optimize a tree representation
2690 for a unary operation. CODE, a tree_code, specifies the operation
2691 and XARG is the operand.
2692 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2693 the default promotions (such as from short to int).
2694 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2695 allows non-lvalues; this is only used to handle conversion of non-lvalue
2696 arrays to pointers in C99. */
2699 build_unary_op (code
, xarg
, flag
)
2700 enum tree_code code
;
2704 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2707 enum tree_code typecode
= TREE_CODE (TREE_TYPE (arg
));
2709 int noconvert
= flag
;
2711 if (typecode
== ERROR_MARK
)
2712 return error_mark_node
;
2713 if (typecode
== ENUMERAL_TYPE
|| typecode
== BOOLEAN_TYPE
)
2714 typecode
= INTEGER_TYPE
;
2719 /* This is used for unary plus, because a CONVERT_EXPR
2720 is enough to prevent anybody from looking inside for
2721 associativity, but won't generate any code. */
2722 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2723 || typecode
== COMPLEX_TYPE
))
2725 error ("wrong type argument to unary plus");
2726 return error_mark_node
;
2728 else if (!noconvert
)
2729 arg
= default_conversion (arg
);
2730 arg
= non_lvalue (arg
);
2734 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2735 || typecode
== COMPLEX_TYPE
2736 || typecode
== VECTOR_TYPE
))
2738 error ("wrong type argument to unary minus");
2739 return error_mark_node
;
2741 else if (!noconvert
)
2742 arg
= default_conversion (arg
);
2746 if (typecode
== INTEGER_TYPE
|| typecode
== VECTOR_TYPE
)
2749 arg
= default_conversion (arg
);
2751 else if (typecode
== COMPLEX_TYPE
)
2755 pedwarn ("ISO C does not support `~' for complex conjugation");
2757 arg
= default_conversion (arg
);
2761 error ("wrong type argument to bit-complement");
2762 return error_mark_node
;
2767 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2768 || typecode
== COMPLEX_TYPE
))
2770 error ("wrong type argument to abs");
2771 return error_mark_node
;
2773 else if (!noconvert
)
2774 arg
= default_conversion (arg
);
2778 /* Conjugating a real value is a no-op, but allow it anyway. */
2779 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
2780 || typecode
== COMPLEX_TYPE
))
2782 error ("wrong type argument to conjugation");
2783 return error_mark_node
;
2785 else if (!noconvert
)
2786 arg
= default_conversion (arg
);
2789 case TRUTH_NOT_EXPR
:
2790 if (typecode
!= INTEGER_TYPE
2791 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
2792 && typecode
!= COMPLEX_TYPE
2793 /* These will convert to a pointer. */
2794 && typecode
!= ARRAY_TYPE
&& typecode
!= FUNCTION_TYPE
)
2796 error ("wrong type argument to unary exclamation mark");
2797 return error_mark_node
;
2799 arg
= c_common_truthvalue_conversion (arg
);
2800 return invert_truthvalue (arg
);
2806 if (TREE_CODE (arg
) == COMPLEX_CST
)
2807 return TREE_REALPART (arg
);
2808 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2809 return fold (build1 (REALPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2814 if (TREE_CODE (arg
) == COMPLEX_CST
)
2815 return TREE_IMAGPART (arg
);
2816 else if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2817 return fold (build1 (IMAGPART_EXPR
, TREE_TYPE (TREE_TYPE (arg
)), arg
));
2819 return convert (TREE_TYPE (arg
), integer_zero_node
);
2821 case PREINCREMENT_EXPR
:
2822 case POSTINCREMENT_EXPR
:
2823 case PREDECREMENT_EXPR
:
2824 case POSTDECREMENT_EXPR
:
2825 /* Handle complex lvalues (when permitted)
2826 by reduction to simpler cases. */
2828 val
= unary_complex_lvalue (code
, arg
, 0);
2832 /* Increment or decrement the real part of the value,
2833 and don't change the imaginary part. */
2834 if (typecode
== COMPLEX_TYPE
)
2839 pedwarn ("ISO C does not support `++' and `--' on complex types");
2841 arg
= stabilize_reference (arg
);
2842 real
= build_unary_op (REALPART_EXPR
, arg
, 1);
2843 imag
= build_unary_op (IMAGPART_EXPR
, arg
, 1);
2844 return build (COMPLEX_EXPR
, TREE_TYPE (arg
),
2845 build_unary_op (code
, real
, 1), imag
);
2848 /* Report invalid types. */
2850 if (typecode
!= POINTER_TYPE
2851 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
)
2853 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2854 error ("wrong type argument to increment");
2856 error ("wrong type argument to decrement");
2858 return error_mark_node
;
2863 tree result_type
= TREE_TYPE (arg
);
2865 arg
= get_unwidened (arg
, 0);
2866 argtype
= TREE_TYPE (arg
);
2868 /* Compute the increment. */
2870 if (typecode
== POINTER_TYPE
)
2872 /* If pointer target is an undefined struct,
2873 we just cannot know how to do the arithmetic. */
2874 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type
)))
2876 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2877 error ("increment of pointer to unknown structure");
2879 error ("decrement of pointer to unknown structure");
2881 else if ((pedantic
|| warn_pointer_arith
)
2882 && (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
2883 || TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
))
2885 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2886 pedwarn ("wrong type argument to increment");
2888 pedwarn ("wrong type argument to decrement");
2891 inc
= c_size_in_bytes (TREE_TYPE (result_type
));
2894 inc
= integer_one_node
;
2896 inc
= convert (argtype
, inc
);
2898 /* Handle incrementing a cast-expression. */
2901 switch (TREE_CODE (arg
))
2906 case FIX_TRUNC_EXPR
:
2907 case FIX_FLOOR_EXPR
:
2908 case FIX_ROUND_EXPR
:
2910 pedantic_lvalue_warning (CONVERT_EXPR
);
2911 /* If the real type has the same machine representation
2912 as the type it is cast to, we can make better output
2913 by adding directly to the inside of the cast. */
2914 if ((TREE_CODE (TREE_TYPE (arg
))
2915 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))))
2916 && (TYPE_MODE (TREE_TYPE (arg
))
2917 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg
, 0)))))
2918 arg
= TREE_OPERAND (arg
, 0);
2921 tree incremented
, modify
, value
;
2922 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
2923 value
= boolean_increment (code
, arg
);
2926 arg
= stabilize_reference (arg
);
2927 if (code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
2930 value
= save_expr (arg
);
2931 incremented
= build (((code
== PREINCREMENT_EXPR
2932 || code
== POSTINCREMENT_EXPR
)
2933 ? PLUS_EXPR
: MINUS_EXPR
),
2934 argtype
, value
, inc
);
2935 TREE_SIDE_EFFECTS (incremented
) = 1;
2936 modify
= build_modify_expr (arg
, NOP_EXPR
, incremented
);
2937 value
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), modify
, value
);
2939 TREE_USED (value
) = 1;
2949 /* Complain about anything else that is not a true lvalue. */
2950 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
2951 || code
== POSTINCREMENT_EXPR
)
2952 ? "invalid lvalue in increment"
2953 : "invalid lvalue in decrement")))
2954 return error_mark_node
;
2956 /* Report a read-only lvalue. */
2957 if (TREE_READONLY (arg
))
2958 readonly_warning (arg
,
2959 ((code
== PREINCREMENT_EXPR
2960 || code
== POSTINCREMENT_EXPR
)
2961 ? "increment" : "decrement"));
2963 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
2964 val
= boolean_increment (code
, arg
);
2966 val
= build (code
, TREE_TYPE (arg
), arg
, inc
);
2967 TREE_SIDE_EFFECTS (val
) = 1;
2968 val
= convert (result_type
, val
);
2969 if (TREE_CODE (val
) != code
)
2970 TREE_NO_UNUSED_WARNING (val
) = 1;
2975 /* Note that this operation never does default_conversion. */
2977 /* Let &* cancel out to simplify resulting code. */
2978 if (TREE_CODE (arg
) == INDIRECT_REF
)
2980 /* Don't let this be an lvalue. */
2981 if (lvalue_p (TREE_OPERAND (arg
, 0)))
2982 return non_lvalue (TREE_OPERAND (arg
, 0));
2983 return TREE_OPERAND (arg
, 0);
2986 /* For &x[y], return x+y */
2987 if (TREE_CODE (arg
) == ARRAY_REF
)
2989 if (!c_mark_addressable (TREE_OPERAND (arg
, 0)))
2990 return error_mark_node
;
2991 return build_binary_op (PLUS_EXPR
, TREE_OPERAND (arg
, 0),
2992 TREE_OPERAND (arg
, 1), 1);
2995 /* Handle complex lvalues (when permitted)
2996 by reduction to simpler cases. */
2997 val
= unary_complex_lvalue (code
, arg
, flag
);
3001 #if 0 /* Turned off because inconsistent;
3002 float f; *&(int)f = 3.4 stores in int format
3003 whereas (int)f = 3.4 stores in float format. */
3004 /* Address of a cast is just a cast of the address
3005 of the operand of the cast. */
3006 switch (TREE_CODE (arg
))
3011 case FIX_TRUNC_EXPR
:
3012 case FIX_FLOOR_EXPR
:
3013 case FIX_ROUND_EXPR
:
3016 pedwarn ("ISO C forbids the address of a cast expression");
3017 return convert (build_pointer_type (TREE_TYPE (arg
)),
3018 build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0),
3023 /* Anything not already handled and not a true memory reference
3024 or a non-lvalue array is an error. */
3025 else if (typecode
!= FUNCTION_TYPE
&& !flag
3026 && !lvalue_or_else (arg
, "invalid lvalue in unary `&'"))
3027 return error_mark_node
;
3029 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3030 argtype
= TREE_TYPE (arg
);
3032 /* If the lvalue is const or volatile, merge that into the type
3033 to which the address will point. Note that you can't get a
3034 restricted pointer by taking the address of something, so we
3035 only have to deal with `const' and `volatile' here. */
3036 if ((DECL_P (arg
) || TREE_CODE_CLASS (TREE_CODE (arg
)) == 'r')
3037 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
)))
3038 argtype
= c_build_type_variant (argtype
,
3039 TREE_READONLY (arg
),
3040 TREE_THIS_VOLATILE (arg
));
3042 argtype
= build_pointer_type (argtype
);
3044 if (!c_mark_addressable (arg
))
3045 return error_mark_node
;
3050 if (TREE_CODE (arg
) == COMPONENT_REF
)
3052 tree field
= TREE_OPERAND (arg
, 1);
3054 addr
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (arg
, 0), flag
);
3056 if (DECL_C_BIT_FIELD (field
))
3058 error ("attempt to take address of bit-field structure member `%s'",
3059 IDENTIFIER_POINTER (DECL_NAME (field
)));
3060 return error_mark_node
;
3063 addr
= fold (build (PLUS_EXPR
, argtype
,
3064 convert (argtype
, addr
),
3065 convert (argtype
, byte_position (field
))));
3068 addr
= build1 (code
, argtype
, arg
);
3070 /* Address of a static or external variable or
3071 file-scope function counts as a constant. */
3073 && ! (TREE_CODE (arg
) == FUNCTION_DECL
3074 && DECL_CONTEXT (arg
) != 0))
3075 TREE_CONSTANT (addr
) = 1;
3084 argtype
= TREE_TYPE (arg
);
3085 return fold (build1 (code
, argtype
, arg
));
3089 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3090 convert ARG with the same conversions in the same order
3091 and return the result. */
3094 convert_sequence (conversions
, arg
)
3098 switch (TREE_CODE (conversions
))
3103 case FIX_TRUNC_EXPR
:
3104 case FIX_FLOOR_EXPR
:
3105 case FIX_ROUND_EXPR
:
3107 return convert (TREE_TYPE (conversions
),
3108 convert_sequence (TREE_OPERAND (conversions
, 0),
3117 /* Return nonzero if REF is an lvalue valid for this language.
3118 Lvalues can be assigned, unless their type has TYPE_READONLY.
3119 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3125 enum tree_code code
= TREE_CODE (ref
);
3132 return lvalue_p (TREE_OPERAND (ref
, 0));
3134 case COMPOUND_LITERAL_EXPR
:
3144 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
3145 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
3149 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
3156 /* Return nonzero if REF is an lvalue valid for this language;
3157 otherwise, print an error message and return zero. */
3160 lvalue_or_else (ref
, msgid
)
3164 int win
= lvalue_p (ref
);
3167 error ("%s", msgid
);
3172 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3173 for certain kinds of expressions which are not really lvalues
3174 but which we can accept as lvalues. If FLAG is nonzero, then
3175 non-lvalues are OK since we may be converting a non-lvalue array to
3178 If ARG is not a kind of expression we can handle, return zero. */
3181 unary_complex_lvalue (code
, arg
, flag
)
3182 enum tree_code code
;
3186 /* Handle (a, b) used as an "lvalue". */
3187 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
3189 tree real_result
= build_unary_op (code
, TREE_OPERAND (arg
, 1), 0);
3191 /* If this returns a function type, it isn't really being used as
3192 an lvalue, so don't issue a warning about it. */
3193 if (TREE_CODE (TREE_TYPE (arg
)) != FUNCTION_TYPE
&& !flag
)
3194 pedantic_lvalue_warning (COMPOUND_EXPR
);
3196 return build (COMPOUND_EXPR
, TREE_TYPE (real_result
),
3197 TREE_OPERAND (arg
, 0), real_result
);
3200 /* Handle (a ? b : c) used as an "lvalue". */
3201 if (TREE_CODE (arg
) == COND_EXPR
)
3204 pedantic_lvalue_warning (COND_EXPR
);
3205 if (TREE_CODE (TREE_TYPE (arg
)) != FUNCTION_TYPE
&& !flag
)
3206 pedantic_lvalue_warning (COMPOUND_EXPR
);
3208 return (build_conditional_expr
3209 (TREE_OPERAND (arg
, 0),
3210 build_unary_op (code
, TREE_OPERAND (arg
, 1), flag
),
3211 build_unary_op (code
, TREE_OPERAND (arg
, 2), flag
)));
3217 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3218 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3221 pedantic_lvalue_warning (code
)
3222 enum tree_code code
;
3228 pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3231 pedwarn ("ISO C forbids use of compound expressions as lvalues");
3234 pedwarn ("ISO C forbids use of cast expressions as lvalues");
3239 /* Warn about storing in something that is `const'. */
3242 readonly_warning (arg
, msgid
)
3246 if (TREE_CODE (arg
) == COMPONENT_REF
)
3248 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
3249 readonly_warning (TREE_OPERAND (arg
, 0), msgid
);
3251 pedwarn ("%s of read-only member `%s'", _(msgid
),
3252 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg
, 1))));
3254 else if (TREE_CODE (arg
) == VAR_DECL
)
3255 pedwarn ("%s of read-only variable `%s'", _(msgid
),
3256 IDENTIFIER_POINTER (DECL_NAME (arg
)));
3258 pedwarn ("%s of read-only location", _(msgid
));
3261 /* Mark EXP saying that we need to be able to take the
3262 address of it; it should not be allocated in a register.
3263 Returns true if successful. */
3266 c_mark_addressable (exp
)
3272 switch (TREE_CODE (x
))
3275 if (DECL_C_BIT_FIELD (TREE_OPERAND (x
, 1)))
3277 error ("cannot take address of bit-field `%s'",
3278 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x
, 1))));
3282 /* ... fall through ... */
3288 x
= TREE_OPERAND (x
, 0);
3291 case COMPOUND_LITERAL_EXPR
:
3293 TREE_ADDRESSABLE (x
) = 1;
3300 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
3301 && DECL_NONLOCAL (x
))
3303 if (TREE_PUBLIC (x
))
3305 error ("global register variable `%s' used in nested function",
3306 IDENTIFIER_POINTER (DECL_NAME (x
)));
3309 pedwarn ("register variable `%s' used in nested function",
3310 IDENTIFIER_POINTER (DECL_NAME (x
)));
3312 else if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
))
3314 if (TREE_PUBLIC (x
))
3316 error ("address of global register variable `%s' requested",
3317 IDENTIFIER_POINTER (DECL_NAME (x
)));
3321 /* If we are making this addressable due to its having
3322 volatile components, give a different error message. Also
3323 handle the case of an unnamed parameter by not trying
3324 to give the name. */
3326 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x
)))
3328 error ("cannot put object with volatile field into register");
3332 pedwarn ("address of register variable `%s' requested",
3333 IDENTIFIER_POINTER (DECL_NAME (x
)));
3335 put_var_into_stack (x
);
3339 TREE_ADDRESSABLE (x
) = 1;
3340 #if 0 /* poplevel deals with this now. */
3341 if (DECL_CONTEXT (x
) == 0)
3342 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
3350 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3353 build_conditional_expr (ifexp
, op1
, op2
)
3354 tree ifexp
, op1
, op2
;
3358 enum tree_code code1
;
3359 enum tree_code code2
;
3360 tree result_type
= NULL
;
3361 tree orig_op1
= op1
, orig_op2
= op2
;
3363 ifexp
= c_common_truthvalue_conversion (default_conversion (ifexp
));
3365 #if 0 /* Produces wrong result if within sizeof. */
3366 /* Don't promote the operands separately if they promote
3367 the same way. Return the unpromoted type and let the combined
3368 value get promoted if necessary. */
3370 if (TREE_TYPE (op1
) == TREE_TYPE (op2
)
3371 && TREE_CODE (TREE_TYPE (op1
)) != ARRAY_TYPE
3372 && TREE_CODE (TREE_TYPE (op1
)) != ENUMERAL_TYPE
3373 && TREE_CODE (TREE_TYPE (op1
)) != FUNCTION_TYPE
)
3375 if (TREE_CODE (ifexp
) == INTEGER_CST
)
3376 return pedantic_non_lvalue (integer_zerop (ifexp
) ? op2
: op1
);
3378 return fold (build (COND_EXPR
, TREE_TYPE (op1
), ifexp
, op1
, op2
));
3382 /* Promote both alternatives. */
3384 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
3385 op1
= default_conversion (op1
);
3386 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
3387 op2
= default_conversion (op2
);
3389 if (TREE_CODE (ifexp
) == ERROR_MARK
3390 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
3391 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
3392 return error_mark_node
;
3394 type1
= TREE_TYPE (op1
);
3395 code1
= TREE_CODE (type1
);
3396 type2
= TREE_TYPE (op2
);
3397 code2
= TREE_CODE (type2
);
3399 /* Quickly detect the usual case where op1 and op2 have the same type
3401 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
3404 result_type
= type1
;
3406 result_type
= TYPE_MAIN_VARIANT (type1
);
3408 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
3409 || code1
== COMPLEX_TYPE
)
3410 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
3411 || code2
== COMPLEX_TYPE
))
3413 result_type
= common_type (type1
, type2
);
3415 /* If -Wsign-compare, warn here if type1 and type2 have
3416 different signedness. We'll promote the signed to unsigned
3417 and later code won't know it used to be different.
3418 Do this check on the original types, so that explicit casts
3419 will be considered, but default promotions won't. */
3420 if ((warn_sign_compare
< 0 ? extra_warnings
: warn_sign_compare
)
3421 && !skip_evaluation
)
3423 int unsigned_op1
= TREE_UNSIGNED (TREE_TYPE (orig_op1
));
3424 int unsigned_op2
= TREE_UNSIGNED (TREE_TYPE (orig_op2
));
3426 if (unsigned_op1
^ unsigned_op2
)
3428 /* Do not warn if the result type is signed, since the
3429 signed type will only be chosen if it can represent
3430 all the values of the unsigned type. */
3431 if (! TREE_UNSIGNED (result_type
))
3433 /* Do not warn if the signed quantity is an unsuffixed
3434 integer literal (or some static constant expression
3435 involving such literals) and it is non-negative. */
3436 else if ((unsigned_op2
&& c_tree_expr_nonnegative_p (op1
))
3437 || (unsigned_op1
&& c_tree_expr_nonnegative_p (op2
)))
3440 warning ("signed and unsigned type in conditional expression");
3444 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
3446 if (pedantic
&& (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
))
3447 pedwarn ("ISO C forbids conditional expr with only one void side");
3448 result_type
= void_type_node
;
3450 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
3452 if (comp_target_types (type1
, type2
, 1))
3453 result_type
= common_type (type1
, type2
);
3454 else if (integer_zerop (op1
) && TREE_TYPE (type1
) == void_type_node
3455 && TREE_CODE (orig_op1
) != NOP_EXPR
)
3456 result_type
= qualify_type (type2
, type1
);
3457 else if (integer_zerop (op2
) && TREE_TYPE (type2
) == void_type_node
3458 && TREE_CODE (orig_op2
) != NOP_EXPR
)
3459 result_type
= qualify_type (type1
, type2
);
3460 else if (VOID_TYPE_P (TREE_TYPE (type1
)))
3462 if (pedantic
&& TREE_CODE (TREE_TYPE (type2
)) == FUNCTION_TYPE
)
3463 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3464 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type1
),
3465 TREE_TYPE (type2
)));
3467 else if (VOID_TYPE_P (TREE_TYPE (type2
)))
3469 if (pedantic
&& TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
3470 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3471 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
3472 TREE_TYPE (type1
)));
3476 pedwarn ("pointer type mismatch in conditional expression");
3477 result_type
= build_pointer_type (void_type_node
);
3480 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
3482 if (! integer_zerop (op2
))
3483 pedwarn ("pointer/integer type mismatch in conditional expression");
3486 op2
= null_pointer_node
;
3488 result_type
= type1
;
3490 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
3492 if (!integer_zerop (op1
))
3493 pedwarn ("pointer/integer type mismatch in conditional expression");
3496 op1
= null_pointer_node
;
3498 result_type
= type2
;
3503 if (flag_cond_mismatch
)
3504 result_type
= void_type_node
;
3507 error ("type mismatch in conditional expression");
3508 return error_mark_node
;
3512 /* Merge const and volatile flags of the incoming types. */
3514 = build_type_variant (result_type
,
3515 TREE_READONLY (op1
) || TREE_READONLY (op2
),
3516 TREE_THIS_VOLATILE (op1
) || TREE_THIS_VOLATILE (op2
));
3518 if (result_type
!= TREE_TYPE (op1
))
3519 op1
= convert_and_check (result_type
, op1
);
3520 if (result_type
!= TREE_TYPE (op2
))
3521 op2
= convert_and_check (result_type
, op2
);
3523 if (TREE_CODE (ifexp
) == INTEGER_CST
)
3524 return pedantic_non_lvalue (integer_zerop (ifexp
) ? op2
: op1
);
3526 return fold (build (COND_EXPR
, result_type
, ifexp
, op1
, op2
));
3529 /* Given a list of expressions, return a compound expression
3530 that performs them all and returns the value of the last of them. */
3533 build_compound_expr (list
)
3536 return internal_build_compound_expr (list
, TRUE
);
3540 internal_build_compound_expr (list
, first_p
)
3546 if (TREE_CHAIN (list
) == 0)
3548 /* Convert arrays and functions to pointers when there
3549 really is a comma operator. */
3552 = default_function_array_conversion (TREE_VALUE (list
));
3554 #if 0 /* If something inside inhibited lvalueness, we should not override. */
3555 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3557 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3558 if (TREE_CODE (list
) == NON_LVALUE_EXPR
)
3559 list
= TREE_OPERAND (list
, 0);
3562 /* Don't let (0, 0) be null pointer constant. */
3563 if (!first_p
&& integer_zerop (TREE_VALUE (list
)))
3564 return non_lvalue (TREE_VALUE (list
));
3565 return TREE_VALUE (list
);
3568 rest
= internal_build_compound_expr (TREE_CHAIN (list
), FALSE
);
3570 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list
)))
3572 /* The left-hand operand of a comma expression is like an expression
3573 statement: with -W or -Wunused, we should warn if it doesn't have
3574 any side-effects, unless it was explicitly cast to (void). */
3575 if ((extra_warnings
|| warn_unused_value
)
3576 && ! (TREE_CODE (TREE_VALUE (list
)) == CONVERT_EXPR
3577 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list
)))))
3578 warning ("left-hand operand of comma expression has no effect");
3580 /* When pedantic, a compound expression can be neither an lvalue
3581 nor an integer constant expression. */
3586 /* With -Wunused, we should also warn if the left-hand operand does have
3587 side-effects, but computes a value which is not used. For example, in
3588 `foo() + bar(), baz()' the result of the `+' operator is not used,
3589 so we should issue a warning. */
3590 else if (warn_unused_value
)
3591 warn_if_unused_value (TREE_VALUE (list
));
3593 return build (COMPOUND_EXPR
, TREE_TYPE (rest
), TREE_VALUE (list
), rest
);
3596 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3599 build_c_cast (type
, expr
)
3605 if (type
== error_mark_node
|| expr
== error_mark_node
)
3606 return error_mark_node
;
3608 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3609 only in <protocol> qualifications. But when constructing cast expressions,
3610 the protocols do matter and must be kept around. */
3611 if (!flag_objc
|| !objc_is_id (type
))
3612 type
= TYPE_MAIN_VARIANT (type
);
3615 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3616 if (TREE_CODE (value
) == NON_LVALUE_EXPR
)
3617 value
= TREE_OPERAND (value
, 0);
3620 if (TREE_CODE (type
) == ARRAY_TYPE
)
3622 error ("cast specifies array type");
3623 return error_mark_node
;
3626 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3628 error ("cast specifies function type");
3629 return error_mark_node
;
3632 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
3636 if (TREE_CODE (type
) == RECORD_TYPE
3637 || TREE_CODE (type
) == UNION_TYPE
)
3638 pedwarn ("ISO C forbids casting nonscalar to the same type");
3641 else if (TREE_CODE (type
) == UNION_TYPE
)
3644 value
= default_function_array_conversion (value
);
3646 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3647 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
3648 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
3656 pedwarn ("ISO C forbids casts to union type");
3657 t
= digest_init (type
, build (CONSTRUCTOR
, type
, NULL_TREE
,
3658 build_tree_list (field
, value
)), 0);
3659 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
3662 error ("cast to union type from type not present in union");
3663 return error_mark_node
;
3669 /* If casting to void, avoid the error that would come
3670 from default_conversion in the case of a non-lvalue array. */
3671 if (type
== void_type_node
)
3672 return build1 (CONVERT_EXPR
, type
, value
);
3674 /* Convert functions and arrays to pointers,
3675 but don't convert any other types. */
3676 value
= default_function_array_conversion (value
);
3677 otype
= TREE_TYPE (value
);
3679 /* Optionally warn about potentially worrisome casts. */
3682 && TREE_CODE (type
) == POINTER_TYPE
3683 && TREE_CODE (otype
) == POINTER_TYPE
)
3685 tree in_type
= type
;
3686 tree in_otype
= otype
;
3690 /* Check that the qualifiers on IN_TYPE are a superset of
3691 the qualifiers of IN_OTYPE. The outermost level of
3692 POINTER_TYPE nodes is uninteresting and we stop as soon
3693 as we hit a non-POINTER_TYPE node on either type. */
3696 in_otype
= TREE_TYPE (in_otype
);
3697 in_type
= TREE_TYPE (in_type
);
3699 /* GNU C allows cv-qualified function types. 'const'
3700 means the function is very pure, 'volatile' means it
3701 can't return. We need to warn when such qualifiers
3702 are added, not when they're taken away. */
3703 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
3704 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
3705 added
|= (TYPE_QUALS (in_type
) & ~TYPE_QUALS (in_otype
));
3707 discarded
|= (TYPE_QUALS (in_otype
) & ~TYPE_QUALS (in_type
));
3709 while (TREE_CODE (in_type
) == POINTER_TYPE
3710 && TREE_CODE (in_otype
) == POINTER_TYPE
);
3713 warning ("cast adds new qualifiers to function type");
3716 /* There are qualifiers present in IN_OTYPE that are not
3717 present in IN_TYPE. */
3718 warning ("cast discards qualifiers from pointer target type");
3721 /* Warn about possible alignment problems. */
3722 if (STRICT_ALIGNMENT
&& warn_cast_align
3723 && TREE_CODE (type
) == POINTER_TYPE
3724 && TREE_CODE (otype
) == POINTER_TYPE
3725 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
3726 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
3727 /* Don't warn about opaque types, where the actual alignment
3728 restriction is unknown. */
3729 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
3730 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
3731 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
3732 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
3733 warning ("cast increases required alignment of target type");
3735 if (TREE_CODE (type
) == INTEGER_TYPE
3736 && TREE_CODE (otype
) == POINTER_TYPE
3737 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3738 && !TREE_CONSTANT (value
))
3739 warning ("cast from pointer to integer of different size");
3741 if (warn_bad_function_cast
3742 && TREE_CODE (value
) == CALL_EXPR
3743 && TREE_CODE (type
) != TREE_CODE (otype
))
3744 warning ("cast does not match function type");
3746 if (TREE_CODE (type
) == POINTER_TYPE
3747 && TREE_CODE (otype
) == INTEGER_TYPE
3748 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
3749 /* Don't warn about converting any constant. */
3750 && !TREE_CONSTANT (value
))
3751 warning ("cast to pointer from integer of different size");
3753 if (TREE_CODE (type
) == POINTER_TYPE
3754 && TREE_CODE (otype
) == POINTER_TYPE
3755 && TREE_CODE (expr
) == ADDR_EXPR
3756 && DECL_P (TREE_OPERAND (expr
, 0))
3757 && flag_strict_aliasing
&& warn_strict_aliasing
3758 && !VOID_TYPE_P (TREE_TYPE (type
)))
3760 /* Casting the address of a decl to non void pointer. Warn
3761 if the cast breaks type based aliasing. */
3762 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)))
3763 warning ("type-punning to incomplete type might break strict-aliasing rules");
3764 else if (!alias_sets_conflict_p
3765 (get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0))),
3766 get_alias_set (TREE_TYPE (type
))))
3767 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3771 value
= convert (type
, value
);
3773 /* Ignore any integer overflow caused by the cast. */
3774 if (TREE_CODE (value
) == INTEGER_CST
)
3776 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
3777 TREE_CONSTANT_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (ovalue
);
3781 /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant. */
3782 if (pedantic
&& TREE_CODE (value
) == INTEGER_CST
3783 && TREE_CODE (expr
) == INTEGER_CST
3784 && TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
)
3785 value
= non_lvalue (value
);
3787 /* If pedantic, don't let a cast be an lvalue. */
3788 if (value
== expr
&& pedantic
)
3789 value
= non_lvalue (value
);
3794 /* Interpret a cast of expression EXPR to type TYPE. */
3796 c_cast_expr (type
, expr
)
3799 int saved_wsp
= warn_strict_prototypes
;
3801 /* This avoids warnings about unprototyped casts on
3802 integers. E.g. "#define SIG_DFL (void(*)())0". */
3803 if (TREE_CODE (expr
) == INTEGER_CST
)
3804 warn_strict_prototypes
= 0;
3805 type
= groktypename (type
);
3806 warn_strict_prototypes
= saved_wsp
;
3808 return build_c_cast (type
, expr
);
3812 /* Build an assignment expression of lvalue LHS from value RHS.
3813 MODIFYCODE is the code for a binary operator that we use
3814 to combine the old value of LHS with RHS to get the new value.
3815 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3818 build_modify_expr (lhs
, modifycode
, rhs
)
3820 enum tree_code modifycode
;
3824 tree lhstype
= TREE_TYPE (lhs
);
3825 tree olhstype
= lhstype
;
3827 /* Types that aren't fully specified cannot be used in assignments. */
3828 lhs
= require_complete_type (lhs
);
3830 /* Avoid duplicate error messages from operands that had errors. */
3831 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
3832 return error_mark_node
;
3834 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3835 /* Do not use STRIP_NOPS here. We do not want an enumerator
3836 whose value is 0 to count as a null pointer constant. */
3837 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
3838 rhs
= TREE_OPERAND (rhs
, 0);
3842 /* Handle control structure constructs used as "lvalues". */
3844 switch (TREE_CODE (lhs
))
3846 /* Handle (a, b) used as an "lvalue". */
3848 pedantic_lvalue_warning (COMPOUND_EXPR
);
3849 newrhs
= build_modify_expr (TREE_OPERAND (lhs
, 1), modifycode
, rhs
);
3850 if (TREE_CODE (newrhs
) == ERROR_MARK
)
3851 return error_mark_node
;
3852 return build (COMPOUND_EXPR
, lhstype
,
3853 TREE_OPERAND (lhs
, 0), newrhs
);
3855 /* Handle (a ? b : c) used as an "lvalue". */
3857 pedantic_lvalue_warning (COND_EXPR
);
3858 rhs
= save_expr (rhs
);
3860 /* Produce (a ? (b = rhs) : (c = rhs))
3861 except that the RHS goes through a save-expr
3862 so the code to compute it is only emitted once. */
3864 = build_conditional_expr (TREE_OPERAND (lhs
, 0),
3865 build_modify_expr (TREE_OPERAND (lhs
, 1),
3867 build_modify_expr (TREE_OPERAND (lhs
, 2),
3869 if (TREE_CODE (cond
) == ERROR_MARK
)
3871 /* Make sure the code to compute the rhs comes out
3872 before the split. */
3873 return build (COMPOUND_EXPR
, TREE_TYPE (lhs
),
3874 /* But cast it to void to avoid an "unused" error. */
3875 convert (void_type_node
, rhs
), cond
);
3881 /* If a binary op has been requested, combine the old LHS value with the RHS
3882 producing the value we should actually store into the LHS. */
3884 if (modifycode
!= NOP_EXPR
)
3886 lhs
= stabilize_reference (lhs
);
3887 newrhs
= build_binary_op (modifycode
, lhs
, rhs
, 1);
3890 /* Handle a cast used as an "lvalue".
3891 We have already performed any binary operator using the value as cast.
3892 Now convert the result to the cast type of the lhs,
3893 and then true type of the lhs and store it there;
3894 then convert result back to the cast type to be the value
3895 of the assignment. */
3897 switch (TREE_CODE (lhs
))
3902 case FIX_TRUNC_EXPR
:
3903 case FIX_FLOOR_EXPR
:
3904 case FIX_ROUND_EXPR
:
3906 newrhs
= default_function_array_conversion (newrhs
);
3908 tree inner_lhs
= TREE_OPERAND (lhs
, 0);
3910 result
= build_modify_expr (inner_lhs
, NOP_EXPR
,
3911 convert (TREE_TYPE (inner_lhs
),
3912 convert (lhstype
, newrhs
)));
3913 if (TREE_CODE (result
) == ERROR_MARK
)
3915 pedantic_lvalue_warning (CONVERT_EXPR
);
3916 return convert (TREE_TYPE (lhs
), result
);
3923 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3924 Reject anything strange now. */
3926 if (!lvalue_or_else (lhs
, "invalid lvalue in assignment"))
3927 return error_mark_node
;
3929 /* Warn about storing in something that is `const'. */
3931 if (TREE_READONLY (lhs
) || TYPE_READONLY (lhstype
)
3932 || ((TREE_CODE (lhstype
) == RECORD_TYPE
3933 || TREE_CODE (lhstype
) == UNION_TYPE
)
3934 && C_TYPE_FIELDS_READONLY (lhstype
)))
3935 readonly_warning (lhs
, "assignment");
3937 /* If storing into a structure or union member,
3938 it has probably been given type `int'.
3939 Compute the type that would go with
3940 the actual amount of storage the member occupies. */
3942 if (TREE_CODE (lhs
) == COMPONENT_REF
3943 && (TREE_CODE (lhstype
) == INTEGER_TYPE
3944 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
3945 || TREE_CODE (lhstype
) == REAL_TYPE
3946 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
3947 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
3949 /* If storing in a field that is in actuality a short or narrower than one,
3950 we must store in the field in its actual type. */
3952 if (lhstype
!= TREE_TYPE (lhs
))
3954 lhs
= copy_node (lhs
);
3955 TREE_TYPE (lhs
) = lhstype
;
3958 /* Convert new value to destination type. */
3960 newrhs
= convert_for_assignment (lhstype
, newrhs
, _("assignment"),
3961 NULL_TREE
, NULL_TREE
, 0);
3962 if (TREE_CODE (newrhs
) == ERROR_MARK
)
3963 return error_mark_node
;
3967 result
= build (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
3968 TREE_SIDE_EFFECTS (result
) = 1;
3970 /* If we got the LHS in a different type for storing in,
3971 convert the result back to the nominal type of LHS
3972 so that the value we return always has the same type
3973 as the LHS argument. */
3975 if (olhstype
== TREE_TYPE (result
))
3977 return convert_for_assignment (olhstype
, result
, _("assignment"),
3978 NULL_TREE
, NULL_TREE
, 0);
3981 /* Convert value RHS to type TYPE as preparation for an assignment
3982 to an lvalue of type TYPE.
3983 The real work of conversion is done by `convert'.
3984 The purpose of this function is to generate error messages
3985 for assignments that are not allowed in C.
3986 ERRTYPE is a string to use in error messages:
3987 "assignment", "return", etc. If it is null, this is parameter passing
3988 for a function call (and different error messages are output).
3990 FUNNAME is the name of the function being called,
3991 as an IDENTIFIER_NODE, or null.
3992 PARMNUM is the number of the argument, for printing in error messages. */
3995 convert_for_assignment (type
, rhs
, errtype
, fundecl
, funname
, parmnum
)
3997 const char *errtype
;
3998 tree fundecl
, funname
;
4001 enum tree_code codel
= TREE_CODE (type
);
4003 enum tree_code coder
;
4005 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4006 /* Do not use STRIP_NOPS here. We do not want an enumerator
4007 whose value is 0 to count as a null pointer constant. */
4008 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
)
4009 rhs
= TREE_OPERAND (rhs
, 0);
4011 if (TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
4012 || TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
)
4013 rhs
= default_conversion (rhs
);
4014 else if (optimize
&& TREE_CODE (rhs
) == VAR_DECL
)
4015 rhs
= decl_constant_value_for_broken_optimization (rhs
);
4017 rhstype
= TREE_TYPE (rhs
);
4018 coder
= TREE_CODE (rhstype
);
4020 if (coder
== ERROR_MARK
)
4021 return error_mark_node
;
4023 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
4025 overflow_warning (rhs
);
4026 /* Check for Objective-C protocols. This will automatically
4027 issue a warning if there are protocol violations. No need to
4028 use the return value. */
4030 objc_comptypes (type
, rhstype
, 0);
4034 if (coder
== VOID_TYPE
)
4036 error ("void value not ignored as it ought to be");
4037 return error_mark_node
;
4039 /* A type converts to a reference to it.
4040 This code doesn't fully support references, it's just for the
4041 special case of va_start and va_copy. */
4042 if (codel
== REFERENCE_TYPE
4043 && comptypes (TREE_TYPE (type
), TREE_TYPE (rhs
)) == 1)
4045 if (!lvalue_p (rhs
))
4047 error ("cannot pass rvalue to reference parameter");
4048 return error_mark_node
;
4050 if (!c_mark_addressable (rhs
))
4051 return error_mark_node
;
4052 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
4054 /* We already know that these two types are compatible, but they
4055 may not be exactly identical. In fact, `TREE_TYPE (type)' is
4056 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4057 likely to be va_list, a typedef to __builtin_va_list, which
4058 is different enough that it will cause problems later. */
4059 if (TREE_TYPE (TREE_TYPE (rhs
)) != TREE_TYPE (type
))
4060 rhs
= build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), rhs
);
4062 rhs
= build1 (NOP_EXPR
, type
, rhs
);
4065 /* Arithmetic types all interconvert, and enum is treated like int. */
4066 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
4067 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
4068 || codel
== BOOLEAN_TYPE
)
4069 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
4070 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
4071 || coder
== BOOLEAN_TYPE
))
4072 return convert_and_check (type
, rhs
);
4074 /* Conversion to a transparent union from its member types.
4075 This applies only to function arguments. */
4076 else if (codel
== UNION_TYPE
&& TYPE_TRANSPARENT_UNION (type
) && ! errtype
)
4079 tree marginal_memb_type
= 0;
4081 for (memb_types
= TYPE_FIELDS (type
); memb_types
;
4082 memb_types
= TREE_CHAIN (memb_types
))
4084 tree memb_type
= TREE_TYPE (memb_types
);
4086 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
4087 TYPE_MAIN_VARIANT (rhstype
)))
4090 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
4093 if (coder
== POINTER_TYPE
)
4095 tree ttl
= TREE_TYPE (memb_type
);
4096 tree ttr
= TREE_TYPE (rhstype
);
4098 /* Any non-function converts to a [const][volatile] void *
4099 and vice versa; otherwise, targets must be the same.
4100 Meanwhile, the lhs target must have all the qualifiers of
4102 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
4103 || comp_target_types (memb_type
, rhstype
, 0))
4105 /* If this type won't generate any warnings, use it. */
4106 if (TYPE_QUALS (ttl
) == TYPE_QUALS (ttr
)
4107 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
4108 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
4109 ? ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
4110 == TYPE_QUALS (ttr
))
4111 : ((TYPE_QUALS (ttl
) | TYPE_QUALS (ttr
))
4112 == TYPE_QUALS (ttl
))))
4115 /* Keep looking for a better type, but remember this one. */
4116 if (! marginal_memb_type
)
4117 marginal_memb_type
= memb_type
;
4121 /* Can convert integer zero to any pointer type. */
4122 if (integer_zerop (rhs
)
4123 || (TREE_CODE (rhs
) == NOP_EXPR
4124 && integer_zerop (TREE_OPERAND (rhs
, 0))))
4126 rhs
= null_pointer_node
;
4131 if (memb_types
|| marginal_memb_type
)
4135 /* We have only a marginally acceptable member type;
4136 it needs a warning. */
4137 tree ttl
= TREE_TYPE (marginal_memb_type
);
4138 tree ttr
= TREE_TYPE (rhstype
);
4140 /* Const and volatile mean something different for function
4141 types, so the usual warnings are not appropriate. */
4142 if (TREE_CODE (ttr
) == FUNCTION_TYPE
4143 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
4145 /* Because const and volatile on functions are
4146 restrictions that say the function will not do
4147 certain things, it is okay to use a const or volatile
4148 function where an ordinary one is wanted, but not
4150 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
4151 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4152 errtype
, funname
, parmnum
);
4154 else if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
4155 warn_for_assignment ("%s discards qualifiers from pointer target type",
4160 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (fundecl
))
4161 pedwarn ("ISO C prohibits argument conversion to union type");
4163 return build1 (NOP_EXPR
, type
, rhs
);
4167 /* Conversions among pointers */
4168 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
4169 && (coder
== codel
))
4171 tree ttl
= TREE_TYPE (type
);
4172 tree ttr
= TREE_TYPE (rhstype
);
4174 /* Any non-function converts to a [const][volatile] void *
4175 and vice versa; otherwise, targets must be the same.
4176 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4177 if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
4178 || comp_target_types (type
, rhstype
, 0)
4179 || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl
))
4180 == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr
))))
4183 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
4186 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4187 which are not ANSI null ptr constants. */
4188 && (!integer_zerop (rhs
) || TREE_CODE (rhs
) == NOP_EXPR
)
4189 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
4190 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4191 errtype
, funname
, parmnum
);
4192 /* Const and volatile mean something different for function types,
4193 so the usual warnings are not appropriate. */
4194 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
4195 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
4197 if (TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
))
4198 warn_for_assignment ("%s discards qualifiers from pointer target type",
4199 errtype
, funname
, parmnum
);
4200 /* If this is not a case of ignoring a mismatch in signedness,
4202 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
4203 || comp_target_types (type
, rhstype
, 0))
4205 /* If there is a mismatch, do warn. */
4207 warn_for_assignment ("pointer targets in %s differ in signedness",
4208 errtype
, funname
, parmnum
);
4210 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
4211 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
4213 /* Because const and volatile on functions are restrictions
4214 that say the function will not do certain things,
4215 it is okay to use a const or volatile function
4216 where an ordinary one is wanted, but not vice-versa. */
4217 if (TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
))
4218 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4219 errtype
, funname
, parmnum
);
4223 warn_for_assignment ("%s from incompatible pointer type",
4224 errtype
, funname
, parmnum
);
4225 return convert (type
, rhs
);
4227 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
4229 /* An explicit constant 0 can convert to a pointer,
4230 or one that results from arithmetic, even including
4231 a cast to integer type. */
4232 if (! (TREE_CODE (rhs
) == INTEGER_CST
&& integer_zerop (rhs
))
4234 ! (TREE_CODE (rhs
) == NOP_EXPR
4235 && TREE_CODE (TREE_TYPE (rhs
)) == INTEGER_TYPE
4236 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == INTEGER_CST
4237 && integer_zerop (TREE_OPERAND (rhs
, 0))))
4239 warn_for_assignment ("%s makes pointer from integer without a cast",
4240 errtype
, funname
, parmnum
);
4241 return convert (type
, rhs
);
4243 return null_pointer_node
;
4245 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
4247 warn_for_assignment ("%s makes integer from pointer without a cast",
4248 errtype
, funname
, parmnum
);
4249 return convert (type
, rhs
);
4251 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
4252 return convert (type
, rhs
);
4258 tree selector
= objc_message_selector ();
4260 if (selector
&& parmnum
> 2)
4261 error ("incompatible type for argument %d of `%s'",
4262 parmnum
- 2, IDENTIFIER_POINTER (selector
));
4264 error ("incompatible type for argument %d of `%s'",
4265 parmnum
, IDENTIFIER_POINTER (funname
));
4268 error ("incompatible type for argument %d of indirect function call",
4272 error ("incompatible types in %s", errtype
);
4274 return error_mark_node
;
4277 /* Convert VALUE for assignment into inlined parameter PARM. */
4280 c_convert_parm_for_inlining (parm
, value
, fn
)
4281 tree parm
, value
, fn
;
4285 /* If FN was prototyped, the value has been converted already
4286 in convert_arguments. */
4287 if (! value
|| TYPE_ARG_TYPES (TREE_TYPE (fn
)))
4290 type
= TREE_TYPE (parm
);
4291 ret
= convert_for_assignment (type
, value
,
4292 (char *) 0 /* arg passing */, fn
,
4294 if (PROMOTE_PROTOTYPES
4295 && INTEGRAL_TYPE_P (type
)
4296 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
4297 ret
= default_conversion (ret
);
4301 /* Print a warning using MSGID.
4302 It gets OPNAME as its one parameter.
4303 if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
4304 Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4305 FUNCTION and ARGNUM are handled specially if we are building an
4306 Objective-C selector. */
4309 warn_for_assignment (msgid
, opname
, function
, argnum
)
4317 tree selector
= objc_message_selector ();
4320 if (selector
&& argnum
> 2)
4322 function
= selector
;
4329 /* Function name is known; supply it. */
4330 const char *const argstring
= _("passing arg of `%s'");
4331 new_opname
= (char *) alloca (IDENTIFIER_LENGTH (function
)
4332 + strlen (argstring
) + 1
4334 sprintf (new_opname
, argstring
,
4335 IDENTIFIER_POINTER (function
));
4339 /* Function name unknown (call through ptr). */
4340 const char *const argnofun
= _("passing arg of pointer to function");
4341 new_opname
= (char *) alloca (strlen (argnofun
) + 1 + 1);
4342 sprintf (new_opname
, argnofun
);
4347 /* Function name is known; supply it. */
4348 const char *const argstring
= _("passing arg %d of `%s'");
4349 new_opname
= (char *) alloca (IDENTIFIER_LENGTH (function
)
4350 + strlen (argstring
) + 1 + 25
4352 sprintf (new_opname
, argstring
, argnum
,
4353 IDENTIFIER_POINTER (function
));
4357 /* Function name unknown (call through ptr); just give arg number. */
4358 const char *const argnofun
= _("passing arg %d of pointer to function");
4359 new_opname
= (char *) alloca (strlen (argnofun
) + 1 + 25 /*%d*/ + 1);
4360 sprintf (new_opname
, argnofun
, argnum
);
4362 opname
= new_opname
;
4364 pedwarn (msgid
, opname
);
4367 /* If VALUE is a compound expr all of whose expressions are constant, then
4368 return its value. Otherwise, return error_mark_node.
4370 This is for handling COMPOUND_EXPRs as initializer elements
4371 which is allowed with a warning when -pedantic is specified. */
4374 valid_compound_expr_initializer (value
, endtype
)
4378 if (TREE_CODE (value
) == COMPOUND_EXPR
)
4380 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
4382 return error_mark_node
;
4383 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
4386 else if (! TREE_CONSTANT (value
)
4387 && ! initializer_constant_valid_p (value
, endtype
))
4388 return error_mark_node
;
4393 /* Perform appropriate conversions on the initial value of a variable,
4394 store it in the declaration DECL,
4395 and print any error messages that are appropriate.
4396 If the init is invalid, store an ERROR_MARK. */
4399 store_init_value (decl
, init
)
4404 /* If variable's type was invalidly declared, just ignore it. */
4406 type
= TREE_TYPE (decl
);
4407 if (TREE_CODE (type
) == ERROR_MARK
)
4410 /* Digest the specified initializer into an expression. */
4412 value
= digest_init (type
, init
, TREE_STATIC (decl
));
4414 /* Store the expression if valid; else report error. */
4417 /* Note that this is the only place we can detect the error
4418 in a case such as struct foo bar = (struct foo) { x, y };
4419 where there is one initial value which is a constructor expression. */
4420 if (value
== error_mark_node
)
4422 else if (TREE_STATIC (decl
) && ! TREE_CONSTANT (value
))
4424 error ("initializer for static variable is not constant");
4425 value
= error_mark_node
;
4427 else if (TREE_STATIC (decl
)
4428 && initializer_constant_valid_p (value
, TREE_TYPE (value
)) == 0)
4430 error ("initializer for static variable uses complicated arithmetic");
4431 value
= error_mark_node
;
4435 if (pedantic
&& TREE_CODE (value
) == CONSTRUCTOR
)
4437 if (! TREE_CONSTANT (value
))
4438 pedwarn ("aggregate initializer is not constant");
4439 else if (! TREE_STATIC (value
))
4440 pedwarn ("aggregate initializer uses complicated arithmetic");
4445 if (warn_traditional
&& !in_system_header
4446 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && ! TREE_STATIC (decl
))
4447 warning ("traditional C rejects automatic aggregate initialization");
4449 DECL_INITIAL (decl
) = value
;
4451 /* ANSI wants warnings about out-of-range constant initializers. */
4452 STRIP_TYPE_NOPS (value
);
4453 constant_expression_warning (value
);
4455 /* Check if we need to set array size from compound literal size. */
4456 if (TREE_CODE (type
) == ARRAY_TYPE
4457 && TYPE_DOMAIN (type
) == 0
4458 && value
!= error_mark_node
)
4460 tree inside_init
= init
;
4462 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
4463 inside_init
= TREE_OPERAND (init
, 0);
4464 inside_init
= fold (inside_init
);
4466 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
4468 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
4470 if (TYPE_DOMAIN (TREE_TYPE (decl
)))
4472 /* For int foo[] = (int [3]){1}; we need to set array size
4473 now since later on array initializer will be just the
4474 brace enclosed list of the compound literal. */
4475 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (decl
));
4477 layout_decl (decl
, 0);
4483 /* Methods for storing and printing names for error messages. */
4485 /* Implement a spelling stack that allows components of a name to be pushed
4486 and popped. Each element on the stack is this structure. */
4498 #define SPELLING_STRING 1
4499 #define SPELLING_MEMBER 2
4500 #define SPELLING_BOUNDS 3
4502 static struct spelling
*spelling
; /* Next stack element (unused). */
4503 static struct spelling
*spelling_base
; /* Spelling stack base. */
4504 static int spelling_size
; /* Size of the spelling stack. */
4506 /* Macros to save and restore the spelling stack around push_... functions.
4507 Alternative to SAVE_SPELLING_STACK. */
4509 #define SPELLING_DEPTH() (spelling - spelling_base)
4510 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4512 /* Push an element on the spelling stack with type KIND and assign VALUE
4515 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4517 int depth = SPELLING_DEPTH (); \
4519 if (depth >= spelling_size) \
4521 spelling_size += 10; \
4522 if (spelling_base == 0) \
4524 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4527 = (struct spelling *) xrealloc (spelling_base, \
4528 spelling_size * sizeof (struct spelling)); \
4529 RESTORE_SPELLING_DEPTH (depth); \
4532 spelling->kind = (KIND); \
4533 spelling->MEMBER = (VALUE); \
4537 /* Push STRING on the stack. Printed literally. */
4540 push_string (string
)
4543 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
4546 /* Push a member name on the stack. Printed as '.' STRING. */
4549 push_member_name (decl
)
4553 const char *const string
4554 = DECL_NAME (decl
) ? IDENTIFIER_POINTER (DECL_NAME (decl
)) : "<anonymous>";
4555 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
4558 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
4561 push_array_bounds (bounds
)
4564 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
4567 /* Compute the maximum size in bytes of the printed spelling. */
4575 for (p
= spelling_base
; p
< spelling
; p
++)
4577 if (p
->kind
== SPELLING_BOUNDS
)
4580 size
+= strlen (p
->u
.s
) + 1;
4586 /* Print the spelling to BUFFER and return it. */
4589 print_spelling (buffer
)
4595 for (p
= spelling_base
; p
< spelling
; p
++)
4596 if (p
->kind
== SPELLING_BOUNDS
)
4598 sprintf (d
, "[%d]", p
->u
.i
);
4604 if (p
->kind
== SPELLING_MEMBER
)
4606 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
4613 /* Issue an error message for a bad initializer component.
4614 MSGID identifies the message.
4615 The component name is taken from the spelling stack. */
4623 error ("%s", _(msgid
));
4624 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4626 error ("(near initialization for `%s')", ofwhat
);
4629 /* Issue a pedantic warning for a bad initializer component.
4630 MSGID identifies the message.
4631 The component name is taken from the spelling stack. */
4634 pedwarn_init (msgid
)
4639 pedwarn ("%s", _(msgid
));
4640 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4642 pedwarn ("(near initialization for `%s')", ofwhat
);
4645 /* Issue a warning for a bad initializer component.
4646 MSGID identifies the message.
4647 The component name is taken from the spelling stack. */
4650 warning_init (msgid
)
4655 warning ("%s", _(msgid
));
4656 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
4658 warning ("(near initialization for `%s')", ofwhat
);
4661 /* Digest the parser output INIT as an initializer for type TYPE.
4662 Return a C expression of type TYPE to represent the initial value.
4664 REQUIRE_CONSTANT requests an error if non-constant initializers or
4665 elements are seen. */
4668 digest_init (type
, init
, require_constant
)
4670 int require_constant
;
4672 enum tree_code code
= TREE_CODE (type
);
4673 tree inside_init
= init
;
4675 if (type
== error_mark_node
4676 || init
== error_mark_node
4677 || TREE_TYPE (init
) == error_mark_node
)
4678 return error_mark_node
;
4680 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4681 /* Do not use STRIP_NOPS here. We do not want an enumerator
4682 whose value is 0 to count as a null pointer constant. */
4683 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
4684 inside_init
= TREE_OPERAND (init
, 0);
4686 inside_init
= fold (inside_init
);
4688 /* Initialization of an array of chars from a string constant
4689 optionally enclosed in braces. */
4691 if (code
== ARRAY_TYPE
)
4693 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
4694 if ((typ1
== char_type_node
4695 || typ1
== signed_char_type_node
4696 || typ1
== unsigned_char_type_node
4697 || typ1
== unsigned_wchar_type_node
4698 || typ1
== signed_wchar_type_node
)
4699 && ((inside_init
&& TREE_CODE (inside_init
) == STRING_CST
)))
4701 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4702 TYPE_MAIN_VARIANT (type
)))
4705 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)))
4707 && TYPE_PRECISION (typ1
) == TYPE_PRECISION (char_type_node
))
4709 error_init ("char-array initialized from wide string");
4710 return error_mark_node
;
4712 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)))
4714 && TYPE_PRECISION (typ1
) != TYPE_PRECISION (char_type_node
))
4716 error_init ("int-array initialized from non-wide string");
4717 return error_mark_node
;
4720 TREE_TYPE (inside_init
) = type
;
4721 if (TYPE_DOMAIN (type
) != 0
4722 && TYPE_SIZE (type
) != 0
4723 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
4724 /* Subtract 1 (or sizeof (wchar_t))
4725 because it's ok to ignore the terminating null char
4726 that is counted in the length of the constant. */
4727 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
4728 TREE_STRING_LENGTH (inside_init
)
4729 - ((TYPE_PRECISION (typ1
)
4730 != TYPE_PRECISION (char_type_node
))
4731 ? (TYPE_PRECISION (wchar_type_node
)
4734 pedwarn_init ("initializer-string for array of chars is too long");
4740 /* Any type can be initialized
4741 from an expression of the same type, optionally with braces. */
4743 if (inside_init
&& TREE_TYPE (inside_init
) != 0
4744 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
4745 TYPE_MAIN_VARIANT (type
))
4746 || (code
== ARRAY_TYPE
4747 && comptypes (TREE_TYPE (inside_init
), type
))
4748 || (code
== VECTOR_TYPE
4749 && comptypes (TREE_TYPE (inside_init
), type
))
4750 || (code
== POINTER_TYPE
4751 && (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
4752 || TREE_CODE (TREE_TYPE (inside_init
)) == FUNCTION_TYPE
)
4753 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
4754 TREE_TYPE (type
)))))
4756 if (code
== POINTER_TYPE
)
4757 inside_init
= default_function_array_conversion (inside_init
);
4759 if (require_constant
&& !flag_isoc99
4760 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
4762 /* As an extension, allow initializing objects with static storage
4763 duration with compound literals (which are then treated just as
4764 the brace enclosed list they contain). */
4765 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
4766 inside_init
= DECL_INITIAL (decl
);
4769 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
4770 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
4772 error_init ("array initialized from non-constant array expression");
4773 return error_mark_node
;
4776 if (optimize
&& TREE_CODE (inside_init
) == VAR_DECL
)
4777 inside_init
= decl_constant_value_for_broken_optimization (inside_init
);
4779 /* Compound expressions can only occur here if -pedantic or
4780 -pedantic-errors is specified. In the later case, we always want
4781 an error. In the former case, we simply want a warning. */
4782 if (require_constant
&& pedantic
4783 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
4786 = valid_compound_expr_initializer (inside_init
,
4787 TREE_TYPE (inside_init
));
4788 if (inside_init
== error_mark_node
)
4789 error_init ("initializer element is not constant");
4791 pedwarn_init ("initializer element is not constant");
4792 if (flag_pedantic_errors
)
4793 inside_init
= error_mark_node
;
4795 else if (require_constant
4796 && (!TREE_CONSTANT (inside_init
)
4797 /* This test catches things like `7 / 0' which
4798 result in an expression for which TREE_CONSTANT
4799 is true, but which is not actually something
4800 that is a legal constant. We really should not
4801 be using this function, because it is a part of
4802 the back-end. Instead, the expression should
4803 already have been turned into ERROR_MARK_NODE. */
4804 || !initializer_constant_valid_p (inside_init
,
4805 TREE_TYPE (inside_init
))))
4807 error_init ("initializer element is not constant");
4808 inside_init
= error_mark_node
;
4814 /* Handle scalar types, including conversions. */
4816 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== POINTER_TYPE
4817 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
|| code
== COMPLEX_TYPE
)
4819 /* Note that convert_for_assignment calls default_conversion
4820 for arrays and functions. We must not call it in the
4821 case where inside_init is a null pointer constant. */
4823 = convert_for_assignment (type
, init
, _("initialization"),
4824 NULL_TREE
, NULL_TREE
, 0);
4826 if (require_constant
&& ! TREE_CONSTANT (inside_init
))
4828 error_init ("initializer element is not constant");
4829 inside_init
= error_mark_node
;
4831 else if (require_constant
4832 && initializer_constant_valid_p (inside_init
, TREE_TYPE (inside_init
)) == 0)
4834 error_init ("initializer element is not computable at load time");
4835 inside_init
= error_mark_node
;
4841 /* Come here only for records and arrays. */
4843 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4845 error_init ("variable-sized object may not be initialized");
4846 return error_mark_node
;
4849 error_init ("invalid initializer");
4850 return error_mark_node
;
4853 /* Handle initializers that use braces. */
4855 /* Type of object we are accumulating a constructor for.
4856 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4857 static tree constructor_type
;
4859 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4861 static tree constructor_fields
;
4863 /* For an ARRAY_TYPE, this is the specified index
4864 at which to store the next element we get. */
4865 static tree constructor_index
;
4867 /* For an ARRAY_TYPE, this is the maximum index. */
4868 static tree constructor_max_index
;
4870 /* For a RECORD_TYPE, this is the first field not yet written out. */
4871 static tree constructor_unfilled_fields
;
4873 /* For an ARRAY_TYPE, this is the index of the first element
4874 not yet written out. */
4875 static tree constructor_unfilled_index
;
4877 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4878 This is so we can generate gaps between fields, when appropriate. */
4879 static tree constructor_bit_index
;
4881 /* If we are saving up the elements rather than allocating them,
4882 this is the list of elements so far (in reverse order,
4883 most recent first). */
4884 static tree constructor_elements
;
4886 /* 1 if constructor should be incrementally stored into a constructor chain,
4887 0 if all the elements should be kept in AVL tree. */
4888 static int constructor_incremental
;
4890 /* 1 if so far this constructor's elements are all compile-time constants. */
4891 static int constructor_constant
;
4893 /* 1 if so far this constructor's elements are all valid address constants. */
4894 static int constructor_simple
;
4896 /* 1 if this constructor is erroneous so far. */
4897 static int constructor_erroneous
;
4899 /* 1 if have called defer_addressed_constants. */
4900 static int constructor_subconstants_deferred
;
4902 /* Structure for managing pending initializer elements, organized as an
4907 struct init_node
*left
, *right
;
4908 struct init_node
*parent
;
4914 /* Tree of pending elements at this constructor level.
4915 These are elements encountered out of order
4916 which belong at places we haven't reached yet in actually
4918 Will never hold tree nodes across GC runs. */
4919 static struct init_node
*constructor_pending_elts
;
4921 /* The SPELLING_DEPTH of this constructor. */
4922 static int constructor_depth
;
4924 /* 0 if implicitly pushing constructor levels is allowed. */
4925 int constructor_no_implicit
= 0; /* 0 for C; 1 for some other languages. */
4927 static int require_constant_value
;
4928 static int require_constant_elements
;
4930 /* DECL node for which an initializer is being read.
4931 0 means we are reading a constructor expression
4932 such as (struct foo) {...}. */
4933 static tree constructor_decl
;
4935 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4936 static const char *constructor_asmspec
;
4938 /* Nonzero if this is an initializer for a top-level decl. */
4939 static int constructor_top_level
;
4941 /* Nonzero if there were any member designators in this initializer. */
4942 static int constructor_designated
;
4944 /* Nesting depth of designator list. */
4945 static int designator_depth
;
4947 /* Nonzero if there were diagnosed errors in this designator list. */
4948 static int designator_errorneous
;
4951 /* This stack has a level for each implicit or explicit level of
4952 structuring in the initializer, including the outermost one. It
4953 saves the values of most of the variables above. */
4955 struct constructor_range_stack
;
4957 struct constructor_stack
4959 struct constructor_stack
*next
;
4964 tree unfilled_index
;
4965 tree unfilled_fields
;
4968 struct init_node
*pending_elts
;
4971 /* If nonzero, this value should replace the entire
4972 constructor at this level. */
4973 tree replacement_value
;
4974 struct constructor_range_stack
*range_stack
;
4984 struct constructor_stack
*constructor_stack
;
4986 /* This stack represents designators from some range designator up to
4987 the last designator in the list. */
4989 struct constructor_range_stack
4991 struct constructor_range_stack
*next
, *prev
;
4992 struct constructor_stack
*stack
;
4999 struct constructor_range_stack
*constructor_range_stack
;
5001 /* This stack records separate initializers that are nested.
5002 Nested initializers can't happen in ANSI C, but GNU C allows them
5003 in cases like { ... (struct foo) { ... } ... }. */
5005 struct initializer_stack
5007 struct initializer_stack
*next
;
5009 const char *asmspec
;
5010 struct constructor_stack
*constructor_stack
;
5011 struct constructor_range_stack
*constructor_range_stack
;
5013 struct spelling
*spelling
;
5014 struct spelling
*spelling_base
;
5017 char require_constant_value
;
5018 char require_constant_elements
;
5022 struct initializer_stack
*initializer_stack
;
5024 /* Prepare to parse and output the initializer for variable DECL. */
5027 start_init (decl
, asmspec_tree
, top_level
)
5033 struct initializer_stack
*p
5034 = (struct initializer_stack
*) xmalloc (sizeof (struct initializer_stack
));
5035 const char *asmspec
= 0;
5038 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
5040 p
->decl
= constructor_decl
;
5041 p
->asmspec
= constructor_asmspec
;
5042 p
->require_constant_value
= require_constant_value
;
5043 p
->require_constant_elements
= require_constant_elements
;
5044 p
->constructor_stack
= constructor_stack
;
5045 p
->constructor_range_stack
= constructor_range_stack
;
5046 p
->elements
= constructor_elements
;
5047 p
->spelling
= spelling
;
5048 p
->spelling_base
= spelling_base
;
5049 p
->spelling_size
= spelling_size
;
5050 p
->deferred
= constructor_subconstants_deferred
;
5051 p
->top_level
= constructor_top_level
;
5052 p
->next
= initializer_stack
;
5053 initializer_stack
= p
;
5055 constructor_decl
= decl
;
5056 constructor_asmspec
= asmspec
;
5057 constructor_subconstants_deferred
= 0;
5058 constructor_designated
= 0;
5059 constructor_top_level
= top_level
;
5063 require_constant_value
= TREE_STATIC (decl
);
5064 require_constant_elements
5065 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
5066 /* For a scalar, you can always use any value to initialize,
5067 even within braces. */
5068 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
5069 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
5070 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
5071 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
5072 locus
= IDENTIFIER_POINTER (DECL_NAME (decl
));
5076 require_constant_value
= 0;
5077 require_constant_elements
= 0;
5078 locus
= "(anonymous)";
5081 constructor_stack
= 0;
5082 constructor_range_stack
= 0;
5084 missing_braces_mentioned
= 0;
5088 RESTORE_SPELLING_DEPTH (0);
5091 push_string (locus
);
5097 struct initializer_stack
*p
= initializer_stack
;
5099 /* Output subconstants (string constants, usually)
5100 that were referenced within this initializer and saved up.
5101 Must do this if and only if we called defer_addressed_constants. */
5102 if (constructor_subconstants_deferred
)
5103 output_deferred_addressed_constants ();
5105 /* Free the whole constructor stack of this initializer. */
5106 while (constructor_stack
)
5108 struct constructor_stack
*q
= constructor_stack
;
5109 constructor_stack
= q
->next
;
5113 if (constructor_range_stack
)
5116 /* Pop back to the data of the outer initializer (if any). */
5117 constructor_decl
= p
->decl
;
5118 constructor_asmspec
= p
->asmspec
;
5119 require_constant_value
= p
->require_constant_value
;
5120 require_constant_elements
= p
->require_constant_elements
;
5121 constructor_stack
= p
->constructor_stack
;
5122 constructor_range_stack
= p
->constructor_range_stack
;
5123 constructor_elements
= p
->elements
;
5124 spelling
= p
->spelling
;
5125 spelling_base
= p
->spelling_base
;
5126 spelling_size
= p
->spelling_size
;
5127 constructor_subconstants_deferred
= p
->deferred
;
5128 constructor_top_level
= p
->top_level
;
5129 initializer_stack
= p
->next
;
5133 /* Call here when we see the initializer is surrounded by braces.
5134 This is instead of a call to push_init_level;
5135 it is matched by a call to pop_init_level.
5137 TYPE is the type to initialize, for a constructor expression.
5138 For an initializer for a decl, TYPE is zero. */
5141 really_start_incremental_init (type
)
5144 struct constructor_stack
*p
5145 = (struct constructor_stack
*) xmalloc (sizeof (struct constructor_stack
));
5148 type
= TREE_TYPE (constructor_decl
);
5150 p
->type
= constructor_type
;
5151 p
->fields
= constructor_fields
;
5152 p
->index
= constructor_index
;
5153 p
->max_index
= constructor_max_index
;
5154 p
->unfilled_index
= constructor_unfilled_index
;
5155 p
->unfilled_fields
= constructor_unfilled_fields
;
5156 p
->bit_index
= constructor_bit_index
;
5157 p
->elements
= constructor_elements
;
5158 p
->constant
= constructor_constant
;
5159 p
->simple
= constructor_simple
;
5160 p
->erroneous
= constructor_erroneous
;
5161 p
->pending_elts
= constructor_pending_elts
;
5162 p
->depth
= constructor_depth
;
5163 p
->replacement_value
= 0;
5167 p
->incremental
= constructor_incremental
;
5168 p
->designated
= constructor_designated
;
5170 constructor_stack
= p
;
5172 constructor_constant
= 1;
5173 constructor_simple
= 1;
5174 constructor_depth
= SPELLING_DEPTH ();
5175 constructor_elements
= 0;
5176 constructor_pending_elts
= 0;
5177 constructor_type
= type
;
5178 constructor_incremental
= 1;
5179 constructor_designated
= 0;
5180 designator_depth
= 0;
5181 designator_errorneous
= 0;
5183 if (TREE_CODE (constructor_type
) == RECORD_TYPE
5184 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5186 constructor_fields
= TYPE_FIELDS (constructor_type
);
5187 /* Skip any nameless bit fields at the beginning. */
5188 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
5189 && DECL_NAME (constructor_fields
) == 0)
5190 constructor_fields
= TREE_CHAIN (constructor_fields
);
5192 constructor_unfilled_fields
= constructor_fields
;
5193 constructor_bit_index
= bitsize_zero_node
;
5195 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5197 if (TYPE_DOMAIN (constructor_type
))
5199 constructor_max_index
5200 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
5202 /* Detect non-empty initializations of zero-length arrays. */
5203 if (constructor_max_index
== NULL_TREE
5204 && TYPE_SIZE (constructor_type
))
5205 constructor_max_index
= build_int_2 (-1, -1);
5207 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5208 to initialize VLAs will cause a proper error; avoid tree
5209 checking errors as well by setting a safe value. */
5210 if (constructor_max_index
5211 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
5212 constructor_max_index
= build_int_2 (-1, -1);
5215 = convert (bitsizetype
,
5216 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
5219 constructor_index
= bitsize_zero_node
;
5221 constructor_unfilled_index
= constructor_index
;
5223 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
5225 /* Vectors are like simple fixed-size arrays. */
5226 constructor_max_index
=
5227 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type
) - 1, 0);
5228 constructor_index
= convert (bitsizetype
, bitsize_zero_node
);
5229 constructor_unfilled_index
= constructor_index
;
5233 /* Handle the case of int x = {5}; */
5234 constructor_fields
= constructor_type
;
5235 constructor_unfilled_fields
= constructor_type
;
5239 /* Push down into a subobject, for initialization.
5240 If this is for an explicit set of braces, IMPLICIT is 0.
5241 If it is because the next element belongs at a lower level,
5242 IMPLICIT is 1 (or 2 if the push is because of designator list). */
5245 push_init_level (implicit
)
5248 struct constructor_stack
*p
;
5249 tree value
= NULL_TREE
;
5251 /* If we've exhausted any levels that didn't have braces,
5253 while (constructor_stack
->implicit
)
5255 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
5256 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5257 && constructor_fields
== 0)
5258 process_init_element (pop_init_level (1));
5259 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
5260 && tree_int_cst_lt (constructor_max_index
, constructor_index
))
5261 process_init_element (pop_init_level (1));
5266 /* Unless this is an explicit brace, we need to preserve previous
5270 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
5271 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5272 && constructor_fields
)
5273 value
= find_init_member (constructor_fields
);
5274 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5275 value
= find_init_member (constructor_index
);
5278 p
= (struct constructor_stack
*) xmalloc (sizeof (struct constructor_stack
));
5279 p
->type
= constructor_type
;
5280 p
->fields
= constructor_fields
;
5281 p
->index
= constructor_index
;
5282 p
->max_index
= constructor_max_index
;
5283 p
->unfilled_index
= constructor_unfilled_index
;
5284 p
->unfilled_fields
= constructor_unfilled_fields
;
5285 p
->bit_index
= constructor_bit_index
;
5286 p
->elements
= constructor_elements
;
5287 p
->constant
= constructor_constant
;
5288 p
->simple
= constructor_simple
;
5289 p
->erroneous
= constructor_erroneous
;
5290 p
->pending_elts
= constructor_pending_elts
;
5291 p
->depth
= constructor_depth
;
5292 p
->replacement_value
= 0;
5293 p
->implicit
= implicit
;
5295 p
->incremental
= constructor_incremental
;
5296 p
->designated
= constructor_designated
;
5297 p
->next
= constructor_stack
;
5299 constructor_stack
= p
;
5301 constructor_constant
= 1;
5302 constructor_simple
= 1;
5303 constructor_depth
= SPELLING_DEPTH ();
5304 constructor_elements
= 0;
5305 constructor_incremental
= 1;
5306 constructor_designated
= 0;
5307 constructor_pending_elts
= 0;
5310 p
->range_stack
= constructor_range_stack
;
5311 constructor_range_stack
= 0;
5312 designator_depth
= 0;
5313 designator_errorneous
= 0;
5316 /* Don't die if an entire brace-pair level is superfluous
5317 in the containing level. */
5318 if (constructor_type
== 0)
5320 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
5321 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5323 /* Don't die if there are extra init elts at the end. */
5324 if (constructor_fields
== 0)
5325 constructor_type
= 0;
5328 constructor_type
= TREE_TYPE (constructor_fields
);
5329 push_member_name (constructor_fields
);
5330 constructor_depth
++;
5333 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5335 constructor_type
= TREE_TYPE (constructor_type
);
5336 push_array_bounds (tree_low_cst (constructor_index
, 0));
5337 constructor_depth
++;
5340 if (constructor_type
== 0)
5342 error_init ("extra brace group at end of initializer");
5343 constructor_fields
= 0;
5344 constructor_unfilled_fields
= 0;
5348 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
5350 constructor_constant
= TREE_CONSTANT (value
);
5351 constructor_simple
= TREE_STATIC (value
);
5352 constructor_elements
= TREE_OPERAND (value
, 1);
5353 if (constructor_elements
5354 && (TREE_CODE (constructor_type
) == RECORD_TYPE
5355 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
5356 set_nonincremental_init ();
5359 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
5361 missing_braces_mentioned
= 1;
5362 warning_init ("missing braces around initializer");
5365 if (TREE_CODE (constructor_type
) == RECORD_TYPE
5366 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5368 constructor_fields
= TYPE_FIELDS (constructor_type
);
5369 /* Skip any nameless bit fields at the beginning. */
5370 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
5371 && DECL_NAME (constructor_fields
) == 0)
5372 constructor_fields
= TREE_CHAIN (constructor_fields
);
5374 constructor_unfilled_fields
= constructor_fields
;
5375 constructor_bit_index
= bitsize_zero_node
;
5377 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
5379 /* Vectors are like simple fixed-size arrays. */
5380 constructor_max_index
=
5381 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type
) - 1, 0);
5382 constructor_index
= convert (bitsizetype
, integer_zero_node
);
5383 constructor_unfilled_index
= constructor_index
;
5385 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5387 if (TYPE_DOMAIN (constructor_type
))
5389 constructor_max_index
5390 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
5392 /* Detect non-empty initializations of zero-length arrays. */
5393 if (constructor_max_index
== NULL_TREE
5394 && TYPE_SIZE (constructor_type
))
5395 constructor_max_index
= build_int_2 (-1, -1);
5397 /* constructor_max_index needs to be an INTEGER_CST. Attempts
5398 to initialize VLAs will cause a proper error; avoid tree
5399 checking errors as well by setting a safe value. */
5400 if (constructor_max_index
5401 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
5402 constructor_max_index
= build_int_2 (-1, -1);
5405 = convert (bitsizetype
,
5406 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
5409 constructor_index
= bitsize_zero_node
;
5411 constructor_unfilled_index
= constructor_index
;
5412 if (value
&& TREE_CODE (value
) == STRING_CST
)
5414 /* We need to split the char/wchar array into individual
5415 characters, so that we don't have to special case it
5417 set_nonincremental_init_from_string (value
);
5422 warning_init ("braces around scalar initializer");
5423 constructor_fields
= constructor_type
;
5424 constructor_unfilled_fields
= constructor_type
;
5428 /* At the end of an implicit or explicit brace level,
5429 finish up that level of constructor.
5430 If we were outputting the elements as they are read, return 0
5431 from inner levels (process_init_element ignores that),
5432 but return error_mark_node from the outermost level
5433 (that's what we want to put in DECL_INITIAL).
5434 Otherwise, return a CONSTRUCTOR expression. */
5437 pop_init_level (implicit
)
5440 struct constructor_stack
*p
;
5441 tree constructor
= 0;
5445 /* When we come to an explicit close brace,
5446 pop any inner levels that didn't have explicit braces. */
5447 while (constructor_stack
->implicit
)
5448 process_init_element (pop_init_level (1));
5450 if (constructor_range_stack
)
5454 p
= constructor_stack
;
5456 /* Error for initializing a flexible array member, or a zero-length
5457 array member in an inappropriate context. */
5458 if (constructor_type
&& constructor_fields
5459 && TREE_CODE (constructor_type
) == ARRAY_TYPE
5460 && TYPE_DOMAIN (constructor_type
)
5461 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
5463 /* Silently discard empty initializations. The parser will
5464 already have pedwarned for empty brackets. */
5465 if (integer_zerop (constructor_unfilled_index
))
5466 constructor_type
= NULL_TREE
;
5467 else if (! TYPE_SIZE (constructor_type
))
5469 if (constructor_depth
> 2)
5470 error_init ("initialization of flexible array member in a nested context");
5472 pedwarn_init ("initialization of a flexible array member");
5474 /* We have already issued an error message for the existence
5475 of a flexible array member not at the end of the structure.
5476 Discard the initializer so that we do not abort later. */
5477 if (TREE_CHAIN (constructor_fields
) != NULL_TREE
)
5478 constructor_type
= NULL_TREE
;
5481 /* Zero-length arrays are no longer special, so we should no longer
5486 /* Warn when some struct elements are implicitly initialized to zero. */
5489 && TREE_CODE (constructor_type
) == RECORD_TYPE
5490 && constructor_unfilled_fields
)
5492 /* Do not warn for flexible array members or zero-length arrays. */
5493 while (constructor_unfilled_fields
5494 && (! DECL_SIZE (constructor_unfilled_fields
)
5495 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
5496 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
5498 /* Do not warn if this level of the initializer uses member
5499 designators; it is likely to be deliberate. */
5500 if (constructor_unfilled_fields
&& !constructor_designated
)
5502 push_member_name (constructor_unfilled_fields
);
5503 warning_init ("missing initializer");
5504 RESTORE_SPELLING_DEPTH (constructor_depth
);
5508 /* Now output all pending elements. */
5509 constructor_incremental
= 1;
5510 output_pending_init_elements (1);
5512 /* Pad out the end of the structure. */
5513 if (p
->replacement_value
)
5514 /* If this closes a superfluous brace pair,
5515 just pass out the element between them. */
5516 constructor
= p
->replacement_value
;
5517 else if (constructor_type
== 0)
5519 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
5520 && TREE_CODE (constructor_type
) != UNION_TYPE
5521 && TREE_CODE (constructor_type
) != ARRAY_TYPE
5522 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
5524 /* A nonincremental scalar initializer--just return
5525 the element, after verifying there is just one. */
5526 if (constructor_elements
== 0)
5528 if (!constructor_erroneous
)
5529 error_init ("empty scalar initializer");
5530 constructor
= error_mark_node
;
5532 else if (TREE_CHAIN (constructor_elements
) != 0)
5534 error_init ("extra elements in scalar initializer");
5535 constructor
= TREE_VALUE (constructor_elements
);
5538 constructor
= TREE_VALUE (constructor_elements
);
5542 if (constructor_erroneous
)
5543 constructor
= error_mark_node
;
5546 constructor
= build (CONSTRUCTOR
, constructor_type
, NULL_TREE
,
5547 nreverse (constructor_elements
));
5548 if (constructor_constant
)
5549 TREE_CONSTANT (constructor
) = 1;
5550 if (constructor_constant
&& constructor_simple
)
5551 TREE_STATIC (constructor
) = 1;
5555 constructor_type
= p
->type
;
5556 constructor_fields
= p
->fields
;
5557 constructor_index
= p
->index
;
5558 constructor_max_index
= p
->max_index
;
5559 constructor_unfilled_index
= p
->unfilled_index
;
5560 constructor_unfilled_fields
= p
->unfilled_fields
;
5561 constructor_bit_index
= p
->bit_index
;
5562 constructor_elements
= p
->elements
;
5563 constructor_constant
= p
->constant
;
5564 constructor_simple
= p
->simple
;
5565 constructor_erroneous
= p
->erroneous
;
5566 constructor_incremental
= p
->incremental
;
5567 constructor_designated
= p
->designated
;
5568 constructor_pending_elts
= p
->pending_elts
;
5569 constructor_depth
= p
->depth
;
5571 constructor_range_stack
= p
->range_stack
;
5572 RESTORE_SPELLING_DEPTH (constructor_depth
);
5574 constructor_stack
= p
->next
;
5577 if (constructor
== 0)
5579 if (constructor_stack
== 0)
5580 return error_mark_node
;
5586 /* Common handling for both array range and field name designators.
5587 ARRAY argument is nonzero for array ranges. Returns zero for success. */
5590 set_designator (array
)
5594 enum tree_code subcode
;
5596 /* Don't die if an entire brace-pair level is superfluous
5597 in the containing level. */
5598 if (constructor_type
== 0)
5601 /* If there were errors in this designator list already, bail out silently. */
5602 if (designator_errorneous
)
5605 if (!designator_depth
)
5607 if (constructor_range_stack
)
5610 /* Designator list starts at the level of closest explicit
5612 while (constructor_stack
->implicit
)
5613 process_init_element (pop_init_level (1));
5614 constructor_designated
= 1;
5618 if (constructor_no_implicit
)
5620 error_init ("initialization designators may not nest");
5624 if (TREE_CODE (constructor_type
) == RECORD_TYPE
5625 || TREE_CODE (constructor_type
) == UNION_TYPE
)
5627 subtype
= TREE_TYPE (constructor_fields
);
5628 if (subtype
!= error_mark_node
)
5629 subtype
= TYPE_MAIN_VARIANT (subtype
);
5631 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5633 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
5638 subcode
= TREE_CODE (subtype
);
5639 if (array
&& subcode
!= ARRAY_TYPE
)
5641 error_init ("array index in non-array initializer");
5644 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
5646 error_init ("field name not in record or union initializer");
5650 constructor_designated
= 1;
5651 push_init_level (2);
5655 /* If there are range designators in designator list, push a new designator
5656 to constructor_range_stack. RANGE_END is end of such stack range or
5657 NULL_TREE if there is no range designator at this level. */
5660 push_range_stack (range_end
)
5663 struct constructor_range_stack
*p
;
5665 p
= (struct constructor_range_stack
*)
5666 ggc_alloc (sizeof (struct constructor_range_stack
));
5667 p
->prev
= constructor_range_stack
;
5669 p
->fields
= constructor_fields
;
5670 p
->range_start
= constructor_index
;
5671 p
->index
= constructor_index
;
5672 p
->stack
= constructor_stack
;
5673 p
->range_end
= range_end
;
5674 if (constructor_range_stack
)
5675 constructor_range_stack
->next
= p
;
5676 constructor_range_stack
= p
;
5679 /* Within an array initializer, specify the next index to be initialized.
5680 FIRST is that index. If LAST is nonzero, then initialize a range
5681 of indices, running from FIRST through LAST. */
5684 set_init_index (first
, last
)
5687 if (set_designator (1))
5690 designator_errorneous
= 1;
5692 while ((TREE_CODE (first
) == NOP_EXPR
5693 || TREE_CODE (first
) == CONVERT_EXPR
5694 || TREE_CODE (first
) == NON_LVALUE_EXPR
)
5695 && (TYPE_MODE (TREE_TYPE (first
))
5696 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first
, 0)))))
5697 first
= TREE_OPERAND (first
, 0);
5700 while ((TREE_CODE (last
) == NOP_EXPR
5701 || TREE_CODE (last
) == CONVERT_EXPR
5702 || TREE_CODE (last
) == NON_LVALUE_EXPR
)
5703 && (TYPE_MODE (TREE_TYPE (last
))
5704 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last
, 0)))))
5705 last
= TREE_OPERAND (last
, 0);
5707 if (TREE_CODE (first
) != INTEGER_CST
)
5708 error_init ("nonconstant array index in initializer");
5709 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
5710 error_init ("nonconstant array index in initializer");
5711 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
5712 error_init ("array index in non-array initializer");
5713 else if (constructor_max_index
5714 && tree_int_cst_lt (constructor_max_index
, first
))
5715 error_init ("array index in initializer exceeds array bounds");
5718 constructor_index
= convert (bitsizetype
, first
);
5722 if (tree_int_cst_equal (first
, last
))
5724 else if (tree_int_cst_lt (last
, first
))
5726 error_init ("empty index range in initializer");
5731 last
= convert (bitsizetype
, last
);
5732 if (constructor_max_index
!= 0
5733 && tree_int_cst_lt (constructor_max_index
, last
))
5735 error_init ("array index range in initializer exceeds array bounds");
5742 designator_errorneous
= 0;
5743 if (constructor_range_stack
|| last
)
5744 push_range_stack (last
);
5748 /* Within a struct initializer, specify the next field to be initialized. */
5751 set_init_label (fieldname
)
5756 if (set_designator (0))
5759 designator_errorneous
= 1;
5761 if (TREE_CODE (constructor_type
) != RECORD_TYPE
5762 && TREE_CODE (constructor_type
) != UNION_TYPE
)
5764 error_init ("field name not in record or union initializer");
5768 for (tail
= TYPE_FIELDS (constructor_type
); tail
;
5769 tail
= TREE_CHAIN (tail
))
5771 if (DECL_NAME (tail
) == fieldname
)
5776 error ("unknown field `%s' specified in initializer",
5777 IDENTIFIER_POINTER (fieldname
));
5780 constructor_fields
= tail
;
5782 designator_errorneous
= 0;
5783 if (constructor_range_stack
)
5784 push_range_stack (NULL_TREE
);
5788 /* Add a new initializer to the tree of pending initializers. PURPOSE
5789 identifies the initializer, either array index or field in a structure.
5790 VALUE is the value of that index or field. */
5793 add_pending_init (purpose
, value
)
5794 tree purpose
, value
;
5796 struct init_node
*p
, **q
, *r
;
5798 q
= &constructor_pending_elts
;
5801 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
5806 if (tree_int_cst_lt (purpose
, p
->purpose
))
5808 else if (tree_int_cst_lt (p
->purpose
, purpose
))
5812 if (TREE_SIDE_EFFECTS (p
->value
))
5813 warning_init ("initialized field with side-effects overwritten");
5823 bitpos
= bit_position (purpose
);
5827 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
5829 else if (p
->purpose
!= purpose
)
5833 if (TREE_SIDE_EFFECTS (p
->value
))
5834 warning_init ("initialized field with side-effects overwritten");
5841 r
= (struct init_node
*) ggc_alloc (sizeof (struct init_node
));
5842 r
->purpose
= purpose
;
5853 struct init_node
*s
;
5857 if (p
->balance
== 0)
5859 else if (p
->balance
< 0)
5866 p
->left
->parent
= p
;
5883 constructor_pending_elts
= r
;
5888 struct init_node
*t
= r
->right
;
5892 r
->right
->parent
= r
;
5897 p
->left
->parent
= p
;
5900 p
->balance
= t
->balance
< 0;
5901 r
->balance
= -(t
->balance
> 0);
5916 constructor_pending_elts
= t
;
5922 /* p->balance == +1; growth of left side balances the node. */
5927 else /* r == p->right */
5929 if (p
->balance
== 0)
5930 /* Growth propagation from right side. */
5932 else if (p
->balance
> 0)
5939 p
->right
->parent
= p
;
5956 constructor_pending_elts
= r
;
5958 else /* r->balance == -1 */
5961 struct init_node
*t
= r
->left
;
5965 r
->left
->parent
= r
;
5970 p
->right
->parent
= p
;
5973 r
->balance
= (t
->balance
< 0);
5974 p
->balance
= -(t
->balance
> 0);
5989 constructor_pending_elts
= t
;
5995 /* p->balance == -1; growth of right side balances the node. */
6006 /* Build AVL tree from a sorted chain. */
6009 set_nonincremental_init ()
6013 if (TREE_CODE (constructor_type
) != RECORD_TYPE
6014 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
6017 for (chain
= constructor_elements
; chain
; chain
= TREE_CHAIN (chain
))
6018 add_pending_init (TREE_PURPOSE (chain
), TREE_VALUE (chain
));
6019 constructor_elements
= 0;
6020 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
6022 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
6023 /* Skip any nameless bit fields at the beginning. */
6024 while (constructor_unfilled_fields
!= 0
6025 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
6026 && DECL_NAME (constructor_unfilled_fields
) == 0)
6027 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
6030 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6032 if (TYPE_DOMAIN (constructor_type
))
6033 constructor_unfilled_index
6034 = convert (bitsizetype
,
6035 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
6037 constructor_unfilled_index
= bitsize_zero_node
;
6039 constructor_incremental
= 0;
6042 /* Build AVL tree from a string constant. */
6045 set_nonincremental_init_from_string (str
)
6048 tree value
, purpose
, type
;
6049 HOST_WIDE_INT val
[2];
6050 const char *p
, *end
;
6051 int byte
, wchar_bytes
, charwidth
, bitpos
;
6053 if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
6056 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
6057 == TYPE_PRECISION (char_type_node
))
6059 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
)))
6060 == TYPE_PRECISION (wchar_type_node
))
6061 wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
6065 charwidth
= TYPE_PRECISION (char_type_node
);
6066 type
= TREE_TYPE (constructor_type
);
6067 p
= TREE_STRING_POINTER (str
);
6068 end
= p
+ TREE_STRING_LENGTH (str
);
6070 for (purpose
= bitsize_zero_node
;
6071 p
< end
&& !tree_int_cst_lt (constructor_max_index
, purpose
);
6072 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
6074 if (wchar_bytes
== 1)
6076 val
[1] = (unsigned char) *p
++;
6083 for (byte
= 0; byte
< wchar_bytes
; byte
++)
6085 if (BYTES_BIG_ENDIAN
)
6086 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
6088 bitpos
= byte
* charwidth
;
6089 val
[bitpos
< HOST_BITS_PER_WIDE_INT
]
6090 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
6091 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
6095 if (!TREE_UNSIGNED (type
))
6097 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
6098 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
6100 if (val
[1] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
6102 val
[1] |= ((HOST_WIDE_INT
) -1) << bitpos
;
6106 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
6111 else if (val
[0] & (((HOST_WIDE_INT
) 1)
6112 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
6113 val
[0] |= ((HOST_WIDE_INT
) -1)
6114 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
6117 value
= build_int_2 (val
[1], val
[0]);
6118 TREE_TYPE (value
) = type
;
6119 add_pending_init (purpose
, value
);
6122 constructor_incremental
= 0;
6125 /* Return value of FIELD in pending initializer or zero if the field was
6126 not initialized yet. */
6129 find_init_member (field
)
6132 struct init_node
*p
;
6134 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6136 if (constructor_incremental
6137 && tree_int_cst_lt (field
, constructor_unfilled_index
))
6138 set_nonincremental_init ();
6140 p
= constructor_pending_elts
;
6143 if (tree_int_cst_lt (field
, p
->purpose
))
6145 else if (tree_int_cst_lt (p
->purpose
, field
))
6151 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
6153 tree bitpos
= bit_position (field
);
6155 if (constructor_incremental
6156 && (!constructor_unfilled_fields
6157 || tree_int_cst_lt (bitpos
,
6158 bit_position (constructor_unfilled_fields
))))
6159 set_nonincremental_init ();
6161 p
= constructor_pending_elts
;
6164 if (field
== p
->purpose
)
6166 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
6172 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
6174 if (constructor_elements
6175 && TREE_PURPOSE (constructor_elements
) == field
)
6176 return TREE_VALUE (constructor_elements
);
6181 /* "Output" the next constructor element.
6182 At top level, really output it to assembler code now.
6183 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6184 TYPE is the data type that the containing data type wants here.
6185 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6187 PENDING if non-nil means output pending elements that belong
6188 right after this element. (PENDING is normally 1;
6189 it is 0 while outputting pending elements, to avoid recursion.) */
6192 output_init_element (value
, type
, field
, pending
)
6193 tree value
, type
, field
;
6196 if (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
6197 || (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
6198 && !(TREE_CODE (value
) == STRING_CST
6199 && TREE_CODE (type
) == ARRAY_TYPE
6200 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
6201 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
6202 TYPE_MAIN_VARIANT (type
))))
6203 value
= default_conversion (value
);
6205 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
6206 && require_constant_value
&& !flag_isoc99
&& pending
)
6208 /* As an extension, allow initializing objects with static storage
6209 duration with compound literals (which are then treated just as
6210 the brace enclosed list they contain). */
6211 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
6212 value
= DECL_INITIAL (decl
);
6215 if (value
== error_mark_node
)
6216 constructor_erroneous
= 1;
6217 else if (!TREE_CONSTANT (value
))
6218 constructor_constant
= 0;
6219 else if (initializer_constant_valid_p (value
, TREE_TYPE (value
)) == 0
6220 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
6221 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6222 && DECL_C_BIT_FIELD (field
)
6223 && TREE_CODE (value
) != INTEGER_CST
))
6224 constructor_simple
= 0;
6226 if (require_constant_value
&& ! TREE_CONSTANT (value
))
6228 error_init ("initializer element is not constant");
6229 value
= error_mark_node
;
6231 else if (require_constant_elements
6232 && initializer_constant_valid_p (value
, TREE_TYPE (value
)) == 0)
6233 pedwarn ("initializer element is not computable at load time");
6235 /* If this field is empty (and not at the end of structure),
6236 don't do anything other than checking the initializer. */
6238 && (TREE_TYPE (field
) == error_mark_node
6239 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
6240 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
6241 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
6242 || TREE_CHAIN (field
)))))
6245 value
= digest_init (type
, value
, require_constant_value
);
6246 if (value
== error_mark_node
)
6248 constructor_erroneous
= 1;
6252 /* If this element doesn't come next in sequence,
6253 put it on constructor_pending_elts. */
6254 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
6255 && (!constructor_incremental
6256 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
6258 if (constructor_incremental
6259 && tree_int_cst_lt (field
, constructor_unfilled_index
))
6260 set_nonincremental_init ();
6262 add_pending_init (field
, value
);
6265 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
6266 && (!constructor_incremental
6267 || field
!= constructor_unfilled_fields
))
6269 /* We do this for records but not for unions. In a union,
6270 no matter which field is specified, it can be initialized
6271 right away since it starts at the beginning of the union. */
6272 if (constructor_incremental
)
6274 if (!constructor_unfilled_fields
)
6275 set_nonincremental_init ();
6278 tree bitpos
, unfillpos
;
6280 bitpos
= bit_position (field
);
6281 unfillpos
= bit_position (constructor_unfilled_fields
);
6283 if (tree_int_cst_lt (bitpos
, unfillpos
))
6284 set_nonincremental_init ();
6288 add_pending_init (field
, value
);
6291 else if (TREE_CODE (constructor_type
) == UNION_TYPE
6292 && constructor_elements
)
6294 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements
)))
6295 warning_init ("initialized field with side-effects overwritten");
6297 /* We can have just one union field set. */
6298 constructor_elements
= 0;
6301 /* Otherwise, output this element either to
6302 constructor_elements or to the assembler file. */
6304 if (field
&& TREE_CODE (field
) == INTEGER_CST
)
6305 field
= copy_node (field
);
6306 constructor_elements
6307 = tree_cons (field
, value
, constructor_elements
);
6309 /* Advance the variable that indicates sequential elements output. */
6310 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6311 constructor_unfilled_index
6312 = size_binop (PLUS_EXPR
, constructor_unfilled_index
,
6314 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
6316 constructor_unfilled_fields
6317 = TREE_CHAIN (constructor_unfilled_fields
);
6319 /* Skip any nameless bit fields. */
6320 while (constructor_unfilled_fields
!= 0
6321 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
6322 && DECL_NAME (constructor_unfilled_fields
) == 0)
6323 constructor_unfilled_fields
=
6324 TREE_CHAIN (constructor_unfilled_fields
);
6326 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
6327 constructor_unfilled_fields
= 0;
6329 /* Now output any pending elements which have become next. */
6331 output_pending_init_elements (0);
6334 /* Output any pending elements which have become next.
6335 As we output elements, constructor_unfilled_{fields,index}
6336 advances, which may cause other elements to become next;
6337 if so, they too are output.
6339 If ALL is 0, we return when there are
6340 no more pending elements to output now.
6342 If ALL is 1, we output space as necessary so that
6343 we can output all the pending elements. */
6346 output_pending_init_elements (all
)
6349 struct init_node
*elt
= constructor_pending_elts
;
6354 /* Look thru the whole pending tree.
6355 If we find an element that should be output now,
6356 output it. Otherwise, set NEXT to the element
6357 that comes first among those still pending. */
6362 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6364 if (tree_int_cst_equal (elt
->purpose
,
6365 constructor_unfilled_index
))
6366 output_init_element (elt
->value
,
6367 TREE_TYPE (constructor_type
),
6368 constructor_unfilled_index
, 0);
6369 else if (tree_int_cst_lt (constructor_unfilled_index
,
6372 /* Advance to the next smaller node. */
6377 /* We have reached the smallest node bigger than the
6378 current unfilled index. Fill the space first. */
6379 next
= elt
->purpose
;
6385 /* Advance to the next bigger node. */
6390 /* We have reached the biggest node in a subtree. Find
6391 the parent of it, which is the next bigger node. */
6392 while (elt
->parent
&& elt
->parent
->right
== elt
)
6395 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
6398 next
= elt
->purpose
;
6404 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
6405 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6407 tree ctor_unfilled_bitpos
, elt_bitpos
;
6409 /* If the current record is complete we are done. */
6410 if (constructor_unfilled_fields
== 0)
6413 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
6414 elt_bitpos
= bit_position (elt
->purpose
);
6415 /* We can't compare fields here because there might be empty
6416 fields in between. */
6417 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
6419 constructor_unfilled_fields
= elt
->purpose
;
6420 output_init_element (elt
->value
, TREE_TYPE (elt
->purpose
),
6423 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
6425 /* Advance to the next smaller node. */
6430 /* We have reached the smallest node bigger than the
6431 current unfilled field. Fill the space first. */
6432 next
= elt
->purpose
;
6438 /* Advance to the next bigger node. */
6443 /* We have reached the biggest node in a subtree. Find
6444 the parent of it, which is the next bigger node. */
6445 while (elt
->parent
&& elt
->parent
->right
== elt
)
6449 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
6450 bit_position (elt
->purpose
))))
6452 next
= elt
->purpose
;
6460 /* Ordinarily return, but not if we want to output all
6461 and there are elements left. */
6462 if (! (all
&& next
!= 0))
6465 /* If it's not incremental, just skip over the gap, so that after
6466 jumping to retry we will output the next successive element. */
6467 if (TREE_CODE (constructor_type
) == RECORD_TYPE
6468 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6469 constructor_unfilled_fields
= next
;
6470 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6471 constructor_unfilled_index
= next
;
6473 /* ELT now points to the node in the pending tree with the next
6474 initializer to output. */
6478 /* Add one non-braced element to the current constructor level.
6479 This adjusts the current position within the constructor's type.
6480 This may also start or terminate implicit levels
6481 to handle a partly-braced initializer.
6483 Once this has found the correct level for the new element,
6484 it calls output_init_element. */
6487 process_init_element (value
)
6490 tree orig_value
= value
;
6491 int string_flag
= value
!= 0 && TREE_CODE (value
) == STRING_CST
;
6493 designator_depth
= 0;
6494 designator_errorneous
= 0;
6496 /* Handle superfluous braces around string cst as in
6497 char x[] = {"foo"}; */
6500 && TREE_CODE (constructor_type
) == ARRAY_TYPE
6501 && TREE_CODE (TREE_TYPE (constructor_type
)) == INTEGER_TYPE
6502 && integer_zerop (constructor_unfilled_index
))
6504 if (constructor_stack
->replacement_value
)
6505 error_init ("excess elements in char array initializer");
6506 constructor_stack
->replacement_value
= value
;
6510 if (constructor_stack
->replacement_value
!= 0)
6512 error_init ("excess elements in struct initializer");
6516 /* Ignore elements of a brace group if it is entirely superfluous
6517 and has already been diagnosed. */
6518 if (constructor_type
== 0)
6521 /* If we've exhausted any levels that didn't have braces,
6523 while (constructor_stack
->implicit
)
6525 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
6526 || TREE_CODE (constructor_type
) == UNION_TYPE
)
6527 && constructor_fields
== 0)
6528 process_init_element (pop_init_level (1));
6529 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
6530 && (constructor_max_index
== 0
6531 || tree_int_cst_lt (constructor_max_index
,
6532 constructor_index
)))
6533 process_init_element (pop_init_level (1));
6538 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6539 if (constructor_range_stack
)
6541 /* If value is a compound literal and we'll be just using its
6542 content, don't put it into a SAVE_EXPR. */
6543 if (TREE_CODE (value
) != COMPOUND_LITERAL_EXPR
6544 || !require_constant_value
6546 value
= save_expr (value
);
6551 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
6554 enum tree_code fieldcode
;
6556 if (constructor_fields
== 0)
6558 pedwarn_init ("excess elements in struct initializer");
6562 fieldtype
= TREE_TYPE (constructor_fields
);
6563 if (fieldtype
!= error_mark_node
)
6564 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6565 fieldcode
= TREE_CODE (fieldtype
);
6567 /* Error for non-static initialization of a flexible array member. */
6568 if (fieldcode
== ARRAY_TYPE
6569 && !require_constant_value
6570 && TYPE_SIZE (fieldtype
) == NULL_TREE
6571 && TREE_CHAIN (constructor_fields
) == NULL_TREE
)
6573 error_init ("non-static initialization of a flexible array member");
6577 /* Accept a string constant to initialize a subarray. */
6579 && fieldcode
== ARRAY_TYPE
6580 && TREE_CODE (TREE_TYPE (fieldtype
)) == INTEGER_TYPE
6583 /* Otherwise, if we have come to a subaggregate,
6584 and we don't have an element of its type, push into it. */
6585 else if (value
!= 0 && !constructor_no_implicit
6586 && value
!= error_mark_node
6587 && TYPE_MAIN_VARIANT (TREE_TYPE (value
)) != fieldtype
6588 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6589 || fieldcode
== UNION_TYPE
))
6591 push_init_level (1);
6597 push_member_name (constructor_fields
);
6598 output_init_element (value
, fieldtype
, constructor_fields
, 1);
6599 RESTORE_SPELLING_DEPTH (constructor_depth
);
6602 /* Do the bookkeeping for an element that was
6603 directly output as a constructor. */
6605 /* For a record, keep track of end position of last field. */
6606 if (DECL_SIZE (constructor_fields
))
6607 constructor_bit_index
6608 = size_binop (PLUS_EXPR
,
6609 bit_position (constructor_fields
),
6610 DECL_SIZE (constructor_fields
));
6612 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6613 /* Skip any nameless bit fields. */
6614 while (constructor_unfilled_fields
!= 0
6615 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
6616 && DECL_NAME (constructor_unfilled_fields
) == 0)
6617 constructor_unfilled_fields
=
6618 TREE_CHAIN (constructor_unfilled_fields
);
6621 constructor_fields
= TREE_CHAIN (constructor_fields
);
6622 /* Skip any nameless bit fields at the beginning. */
6623 while (constructor_fields
!= 0
6624 && DECL_C_BIT_FIELD (constructor_fields
)
6625 && DECL_NAME (constructor_fields
) == 0)
6626 constructor_fields
= TREE_CHAIN (constructor_fields
);
6628 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
6631 enum tree_code fieldcode
;
6633 if (constructor_fields
== 0)
6635 pedwarn_init ("excess elements in union initializer");
6639 fieldtype
= TREE_TYPE (constructor_fields
);
6640 if (fieldtype
!= error_mark_node
)
6641 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
6642 fieldcode
= TREE_CODE (fieldtype
);
6644 /* Warn that traditional C rejects initialization of unions.
6645 We skip the warning if the value is zero. This is done
6646 under the assumption that the zero initializer in user
6647 code appears conditioned on e.g. __STDC__ to avoid
6648 "missing initializer" warnings and relies on default
6649 initialization to zero in the traditional C case.
6650 We also skip the warning if the initializer is designated,
6651 again on the assumption that this must be conditional on
6652 __STDC__ anyway (and we've already complained about the
6653 member-designator already). */
6654 if (warn_traditional
&& !in_system_header
&& !constructor_designated
6655 && !(value
&& (integer_zerop (value
) || real_zerop (value
))))
6656 warning ("traditional C rejects initialization of unions");
6658 /* Accept a string constant to initialize a subarray. */
6660 && fieldcode
== ARRAY_TYPE
6661 && TREE_CODE (TREE_TYPE (fieldtype
)) == INTEGER_TYPE
6664 /* Otherwise, if we have come to a subaggregate,
6665 and we don't have an element of its type, push into it. */
6666 else if (value
!= 0 && !constructor_no_implicit
6667 && value
!= error_mark_node
6668 && TYPE_MAIN_VARIANT (TREE_TYPE (value
)) != fieldtype
6669 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
6670 || fieldcode
== UNION_TYPE
))
6672 push_init_level (1);
6678 push_member_name (constructor_fields
);
6679 output_init_element (value
, fieldtype
, constructor_fields
, 1);
6680 RESTORE_SPELLING_DEPTH (constructor_depth
);
6683 /* Do the bookkeeping for an element that was
6684 directly output as a constructor. */
6686 constructor_bit_index
= DECL_SIZE (constructor_fields
);
6687 constructor_unfilled_fields
= TREE_CHAIN (constructor_fields
);
6690 constructor_fields
= 0;
6692 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
6694 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6695 enum tree_code eltcode
= TREE_CODE (elttype
);
6697 /* Accept a string constant to initialize a subarray. */
6699 && eltcode
== ARRAY_TYPE
6700 && TREE_CODE (TREE_TYPE (elttype
)) == INTEGER_TYPE
6703 /* Otherwise, if we have come to a subaggregate,
6704 and we don't have an element of its type, push into it. */
6705 else if (value
!= 0 && !constructor_no_implicit
6706 && value
!= error_mark_node
6707 && TYPE_MAIN_VARIANT (TREE_TYPE (value
)) != elttype
6708 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
6709 || eltcode
== UNION_TYPE
))
6711 push_init_level (1);
6715 if (constructor_max_index
!= 0
6716 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
6717 || integer_all_onesp (constructor_max_index
)))
6719 pedwarn_init ("excess elements in array initializer");
6723 /* Now output the actual element. */
6726 push_array_bounds (tree_low_cst (constructor_index
, 0));
6727 output_init_element (value
, elttype
, constructor_index
, 1);
6728 RESTORE_SPELLING_DEPTH (constructor_depth
);
6732 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6735 /* If we are doing the bookkeeping for an element that was
6736 directly output as a constructor, we must update
6737 constructor_unfilled_index. */
6738 constructor_unfilled_index
= constructor_index
;
6740 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
6742 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
6744 /* Do a basic check of initializer size. Note that vectors
6745 always have a fixed size derived from their type. */
6746 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
6748 pedwarn_init ("excess elements in vector initializer");
6752 /* Now output the actual element. */
6754 output_init_element (value
, elttype
, constructor_index
, 1);
6757 = size_binop (PLUS_EXPR
, constructor_index
, bitsize_one_node
);
6760 /* If we are doing the bookkeeping for an element that was
6761 directly output as a constructor, we must update
6762 constructor_unfilled_index. */
6763 constructor_unfilled_index
= constructor_index
;
6766 /* Handle the sole element allowed in a braced initializer
6767 for a scalar variable. */
6768 else if (constructor_fields
== 0)
6770 pedwarn_init ("excess elements in scalar initializer");
6776 output_init_element (value
, constructor_type
, NULL_TREE
, 1);
6777 constructor_fields
= 0;
6780 /* Handle range initializers either at this level or anywhere higher
6781 in the designator stack. */
6782 if (constructor_range_stack
)
6784 struct constructor_range_stack
*p
, *range_stack
;
6787 range_stack
= constructor_range_stack
;
6788 constructor_range_stack
= 0;
6789 while (constructor_stack
!= range_stack
->stack
)
6791 if (!constructor_stack
->implicit
)
6793 process_init_element (pop_init_level (1));
6795 for (p
= range_stack
;
6796 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
6799 if (!constructor_stack
->implicit
)
6801 process_init_element (pop_init_level (1));
6804 p
->index
= size_binop (PLUS_EXPR
, p
->index
, bitsize_one_node
);
6805 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
6810 constructor_index
= p
->index
;
6811 constructor_fields
= p
->fields
;
6812 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
6820 push_init_level (2);
6821 p
->stack
= constructor_stack
;
6822 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
6823 p
->index
= p
->range_start
;
6827 constructor_range_stack
= range_stack
;
6834 constructor_range_stack
= 0;
6837 /* Build a simple asm-statement, from one string literal. */
6839 simple_asm_stmt (expr
)
6844 if (TREE_CODE (expr
) == ADDR_EXPR
)
6845 expr
= TREE_OPERAND (expr
, 0);
6847 if (TREE_CODE (expr
) == STRING_CST
)
6851 stmt
= add_stmt (build_stmt (ASM_STMT
, NULL_TREE
, expr
,
6852 NULL_TREE
, NULL_TREE
,
6854 ASM_INPUT_P (stmt
) = 1;
6858 error ("argument of `asm' is not a constant string");
6862 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6863 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6866 build_asm_stmt (cv_qualifier
, string
, outputs
, inputs
, clobbers
)
6875 if (TREE_CODE (string
) != STRING_CST
)
6877 error ("asm template is not a string constant");
6881 if (cv_qualifier
!= NULL_TREE
6882 && cv_qualifier
!= ridpointers
[(int) RID_VOLATILE
])
6884 warning ("%s qualifier ignored on asm",
6885 IDENTIFIER_POINTER (cv_qualifier
));
6886 cv_qualifier
= NULL_TREE
;
6889 /* We can remove output conversions that change the type,
6890 but not the mode. */
6891 for (tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
))
6893 tree output
= TREE_VALUE (tail
);
6895 STRIP_NOPS (output
);
6896 TREE_VALUE (tail
) = output
;
6898 /* Allow conversions as LHS here. build_modify_expr as called below
6899 will do the right thing with them. */
6900 while (TREE_CODE (output
) == NOP_EXPR
6901 || TREE_CODE (output
) == CONVERT_EXPR
6902 || TREE_CODE (output
) == FLOAT_EXPR
6903 || TREE_CODE (output
) == FIX_TRUNC_EXPR
6904 || TREE_CODE (output
) == FIX_FLOOR_EXPR
6905 || TREE_CODE (output
) == FIX_ROUND_EXPR
6906 || TREE_CODE (output
) == FIX_CEIL_EXPR
)
6907 output
= TREE_OPERAND (output
, 0);
6909 lvalue_or_else (TREE_VALUE (tail
), "invalid lvalue in asm statement");
6912 /* Remove output conversions that change the type but not the mode. */
6913 for (tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
))
6915 tree output
= TREE_VALUE (tail
);
6916 STRIP_NOPS (output
);
6917 TREE_VALUE (tail
) = output
;
6920 /* Perform default conversions on array and function inputs.
6921 Don't do this for other types as it would screw up operands
6922 expected to be in memory. */
6923 for (tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
))
6924 TREE_VALUE (tail
) = default_function_array_conversion (TREE_VALUE (tail
));
6926 return add_stmt (build_stmt (ASM_STMT
, cv_qualifier
, string
,
6927 outputs
, inputs
, clobbers
));
6930 /* Expand an ASM statement with operands, handling output operands
6931 that are not variables or INDIRECT_REFS by transforming such
6932 cases into cases that expand_asm_operands can handle.
6934 Arguments are same as for expand_asm_operands. */
6937 c_expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
6938 tree string
, outputs
, inputs
, clobbers
;
6940 const char *filename
;
6943 int noutputs
= list_length (outputs
);
6945 /* o[I] is the place that output number I should be written. */
6946 tree
*o
= (tree
*) alloca (noutputs
* sizeof (tree
));
6949 /* Record the contents of OUTPUTS before it is modified. */
6950 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6952 o
[i
] = TREE_VALUE (tail
);
6953 if (o
[i
] == error_mark_node
)
6957 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6958 OUTPUTS some trees for where the values were actually stored. */
6959 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
);
6961 /* Copy all the intermediate outputs into the specified outputs. */
6962 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
6964 if (o
[i
] != TREE_VALUE (tail
))
6966 expand_expr (build_modify_expr (o
[i
], NOP_EXPR
, TREE_VALUE (tail
)),
6967 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
6970 /* Restore the original value so that it's correct the next
6971 time we expand this function. */
6972 TREE_VALUE (tail
) = o
[i
];
6974 /* Detect modification of read-only values.
6975 (Otherwise done by build_modify_expr.) */
6978 tree type
= TREE_TYPE (o
[i
]);
6979 if (TREE_READONLY (o
[i
])
6980 || TYPE_READONLY (type
)
6981 || ((TREE_CODE (type
) == RECORD_TYPE
6982 || TREE_CODE (type
) == UNION_TYPE
)
6983 && C_TYPE_FIELDS_READONLY (type
)))
6984 readonly_warning (o
[i
], "modification by `asm'");
6988 /* Those MODIFY_EXPRs could do autoincrements. */
6992 /* Expand a C `return' statement.
6993 RETVAL is the expression for what to return,
6994 or a null pointer for `return;' with no value. */
6997 c_expand_return (retval
)
7000 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7002 if (TREE_THIS_VOLATILE (current_function_decl
))
7003 warning ("function declared `noreturn' has a `return' statement");
7007 current_function_returns_null
= 1;
7008 if ((warn_return_type
|| flag_isoc99
)
7009 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
7010 pedwarn_c99 ("`return' with no value, in function returning non-void");
7012 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
7014 current_function_returns_null
= 1;
7015 if (pedantic
|| TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
7016 pedwarn ("`return' with a value, in function returning void");
7020 tree t
= convert_for_assignment (valtype
, retval
, _("return"),
7021 NULL_TREE
, NULL_TREE
, 0);
7022 tree res
= DECL_RESULT (current_function_decl
);
7025 current_function_returns_value
= 1;
7026 if (t
== error_mark_node
)
7029 inner
= t
= convert (TREE_TYPE (res
), t
);
7031 /* Strip any conversions, additions, and subtractions, and see if
7032 we are returning the address of a local variable. Warn if so. */
7035 switch (TREE_CODE (inner
))
7037 case NOP_EXPR
: case NON_LVALUE_EXPR
: case CONVERT_EXPR
:
7039 inner
= TREE_OPERAND (inner
, 0);
7043 /* If the second operand of the MINUS_EXPR has a pointer
7044 type (or is converted from it), this may be valid, so
7045 don't give a warning. */
7047 tree op1
= TREE_OPERAND (inner
, 1);
7049 while (! POINTER_TYPE_P (TREE_TYPE (op1
))
7050 && (TREE_CODE (op1
) == NOP_EXPR
7051 || TREE_CODE (op1
) == NON_LVALUE_EXPR
7052 || TREE_CODE (op1
) == CONVERT_EXPR
))
7053 op1
= TREE_OPERAND (op1
, 0);
7055 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
7058 inner
= TREE_OPERAND (inner
, 0);
7063 inner
= TREE_OPERAND (inner
, 0);
7065 while (TREE_CODE_CLASS (TREE_CODE (inner
)) == 'r')
7066 inner
= TREE_OPERAND (inner
, 0);
7068 if (TREE_CODE (inner
) == VAR_DECL
7069 && ! DECL_EXTERNAL (inner
)
7070 && ! TREE_STATIC (inner
)
7071 && DECL_CONTEXT (inner
) == current_function_decl
)
7072 warning ("function returns address of local variable");
7082 retval
= build (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
7085 return add_stmt (build_return_stmt (retval
));
7089 /* The SWITCH_STMT being built. */
7091 /* A splay-tree mapping the low element of a case range to the high
7092 element, or NULL_TREE if there is no high element. Used to
7093 determine whether or not a new case label duplicates an old case
7094 label. We need a tree, rather than simply a hash table, because
7095 of the GNU case range extension. */
7097 /* The next node on the stack. */
7098 struct c_switch
*next
;
7101 /* A stack of the currently active switch statements. The innermost
7102 switch statement is on the top of the stack. There is no need to
7103 mark the stack for garbage collection because it is only active
7104 during the processing of the body of a function, and we never
7105 collect at that point. */
7107 static struct c_switch
*switch_stack
;
7109 /* Start a C switch statement, testing expression EXP. Return the new
7116 enum tree_code code
;
7117 tree type
, orig_type
= error_mark_node
;
7118 struct c_switch
*cs
;
7120 if (exp
!= error_mark_node
)
7122 code
= TREE_CODE (TREE_TYPE (exp
));
7123 orig_type
= TREE_TYPE (exp
);
7125 if (! INTEGRAL_TYPE_P (orig_type
)
7126 && code
!= ERROR_MARK
)
7128 error ("switch quantity not an integer");
7129 exp
= integer_zero_node
;
7133 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
7135 if (warn_traditional
&& !in_system_header
7136 && (type
== long_integer_type_node
7137 || type
== long_unsigned_type_node
))
7138 warning ("`long' switch expression not converted to `int' in ISO C");
7140 exp
= default_conversion (exp
);
7141 type
= TREE_TYPE (exp
);
7145 /* Add this new SWITCH_STMT to the stack. */
7146 cs
= (struct c_switch
*) xmalloc (sizeof (*cs
));
7147 cs
->switch_stmt
= build_stmt (SWITCH_STMT
, exp
, NULL_TREE
, orig_type
);
7148 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
7149 cs
->next
= switch_stack
;
7152 return add_stmt (switch_stack
->switch_stmt
);
7155 /* Process a case label. */
7158 do_case (low_value
, high_value
)
7162 tree label
= NULL_TREE
;
7166 label
= c_add_case_label (switch_stack
->cases
,
7167 SWITCH_COND (switch_stack
->switch_stmt
),
7168 low_value
, high_value
);
7169 if (label
== error_mark_node
)
7173 error ("case label not within a switch statement");
7175 error ("`default' label not within a switch statement");
7180 /* Finish the switch statement. */
7185 struct c_switch
*cs
= switch_stack
;
7187 RECHAIN_STMTS (cs
->switch_stmt
, SWITCH_BODY (cs
->switch_stmt
));
7189 /* Pop the stack. */
7190 switch_stack
= switch_stack
->next
;
7191 splay_tree_delete (cs
->cases
);