OSDN Git Service

6d7723394c9215ceaf562ee3a0ca287666db65d8
[pf3gnuchains/gcc-fork.git] / gcc / c-typeck.c
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, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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
10 version.
11
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
15 for more details.
16
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
20 02111-1307, USA.  */
21
22
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.  */
27
28 #include "config.h"
29 #include "system.h"
30 #include "coretypes.h"
31 #include "tm.h"
32 #include "rtl.h"
33 #include "tree.h"
34 #include "langhooks.h"
35 #include "c-tree.h"
36 #include "tm_p.h"
37 #include "flags.h"
38 #include "output.h"
39 #include "expr.h"
40 #include "toplev.h"
41 #include "intl.h"
42 #include "ggc.h"
43 #include "target.h"
44 #include "tree-iterator.h"
45 #include "tree-gimple.h"
46
47 /* Places where an lvalue, or modifiable lvalue, may be required.
48    Used to select diagnostic messages in lvalue_or_else and
49    readonly_error.  */
50 enum lvalue_use {
51   lv_assign,
52   lv_increment,
53   lv_decrement,
54   lv_addressof,
55   lv_asm
56 };
57
58 /* The level of nesting inside "__alignof__".  */
59 int in_alignof;
60
61 /* The level of nesting inside "sizeof".  */
62 int in_sizeof;
63
64 /* The level of nesting inside "typeof".  */
65 int in_typeof;
66
67 /* Nonzero if we've already printed a "missing braces around initializer"
68    message within this initializer.  */
69 static int missing_braces_mentioned;
70
71 static int require_constant_value;
72 static int require_constant_elements;
73
74 static tree qualify_type (tree, tree);
75 static int tagged_types_tu_compatible_p (tree, tree);
76 static int comp_target_types (tree, tree, int);
77 static int function_types_compatible_p (tree, tree);
78 static int type_lists_compatible_p (tree, tree);
79 static tree decl_constant_value_for_broken_optimization (tree);
80 static tree default_function_array_conversion (tree);
81 static tree lookup_field (tree, tree);
82 static tree convert_arguments (tree, tree, tree, tree);
83 static tree pointer_diff (tree, tree);
84 static tree convert_for_assignment (tree, tree, const char *, tree, tree,
85                                     int);
86 static void warn_for_assignment (const char *, const char *, tree, int);
87 static tree valid_compound_expr_initializer (tree, tree);
88 static void push_string (const char *);
89 static void push_member_name (tree);
90 static void push_array_bounds (int);
91 static int spelling_length (void);
92 static char *print_spelling (char *);
93 static void warning_init (const char *);
94 static tree digest_init (tree, tree, bool, int);
95 static void output_init_element (tree, bool, tree, tree, int);
96 static void output_pending_init_elements (int);
97 static int set_designator (int);
98 static void push_range_stack (tree);
99 static void add_pending_init (tree, tree);
100 static void set_nonincremental_init (void);
101 static void set_nonincremental_init_from_string (tree);
102 static tree find_init_member (tree);
103 static int lvalue_or_else (tree, enum lvalue_use);
104 static void readonly_error (tree, enum lvalue_use);
105 \f
106 /* Do `exp = require_complete_type (exp);' to make sure exp
107    does not have an incomplete type.  (That includes void types.)  */
108
109 tree
110 require_complete_type (tree value)
111 {
112   tree type = TREE_TYPE (value);
113
114   if (value == error_mark_node || type == error_mark_node)
115     return error_mark_node;
116
117   /* First, detect a valid value with a complete type.  */
118   if (COMPLETE_TYPE_P (type))
119     return value;
120
121   c_incomplete_type_error (value, type);
122   return error_mark_node;
123 }
124
125 /* Print an error message for invalid use of an incomplete type.
126    VALUE is the expression that was used (or 0 if that isn't known)
127    and TYPE is the type that was invalid.  */
128
129 void
130 c_incomplete_type_error (tree value, tree type)
131 {
132   const char *type_code_string;
133
134   /* Avoid duplicate error message.  */
135   if (TREE_CODE (type) == ERROR_MARK)
136     return;
137
138   if (value != 0 && (TREE_CODE (value) == VAR_DECL
139                      || TREE_CODE (value) == PARM_DECL))
140     error ("%qs has an incomplete type",
141            IDENTIFIER_POINTER (DECL_NAME (value)));
142   else
143     {
144     retry:
145       /* We must print an error message.  Be clever about what it says.  */
146
147       switch (TREE_CODE (type))
148         {
149         case RECORD_TYPE:
150           type_code_string = "struct";
151           break;
152
153         case UNION_TYPE:
154           type_code_string = "union";
155           break;
156
157         case ENUMERAL_TYPE:
158           type_code_string = "enum";
159           break;
160
161         case VOID_TYPE:
162           error ("invalid use of void expression");
163           return;
164
165         case ARRAY_TYPE:
166           if (TYPE_DOMAIN (type))
167             {
168               if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
169                 {
170                   error ("invalid use of flexible array member");
171                   return;
172                 }
173               type = TREE_TYPE (type);
174               goto retry;
175             }
176           error ("invalid use of array with unspecified bounds");
177           return;
178
179         default:
180           gcc_unreachable ();
181         }
182
183       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
184         error ("invalid use of undefined type %<%s %s%>",
185                type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
186       else
187         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
188         error ("invalid use of incomplete typedef %qs",
189                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
190     }
191 }
192
193 /* Given a type, apply default promotions wrt unnamed function
194    arguments and return the new type.  */
195
196 tree
197 c_type_promotes_to (tree type)
198 {
199   if (TYPE_MAIN_VARIANT (type) == float_type_node)
200     return double_type_node;
201
202   if (c_promoting_integer_type_p (type))
203     {
204       /* Preserve unsignedness if not really getting any wider.  */
205       if (TYPE_UNSIGNED (type)
206           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
207         return unsigned_type_node;
208       return integer_type_node;
209     }
210
211   return type;
212 }
213
214 /* Return a variant of TYPE which has all the type qualifiers of LIKE
215    as well as those of TYPE.  */
216
217 static tree
218 qualify_type (tree type, tree like)
219 {
220   return c_build_qualified_type (type,
221                                  TYPE_QUALS (type) | TYPE_QUALS (like));
222 }
223 \f
224 /* Return the composite type of two compatible types.
225
226    We assume that comptypes has already been done and returned
227    nonzero; if that isn't so, this may crash.  In particular, we
228    assume that qualifiers match.  */
229
230 tree
231 composite_type (tree t1, tree t2)
232 {
233   enum tree_code code1;
234   enum tree_code code2;
235   tree attributes;
236
237   /* Save time if the two types are the same.  */
238
239   if (t1 == t2) return t1;
240
241   /* If one type is nonsense, use the other.  */
242   if (t1 == error_mark_node)
243     return t2;
244   if (t2 == error_mark_node)
245     return t1;
246
247   code1 = TREE_CODE (t1);
248   code2 = TREE_CODE (t2);
249
250   /* Merge the attributes.  */
251   attributes = targetm.merge_type_attributes (t1, t2);
252
253   /* If one is an enumerated type and the other is the compatible
254      integer type, the composite type might be either of the two
255      (DR#013 question 3).  For consistency, use the enumerated type as
256      the composite type.  */
257
258   if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
259     return t1;
260   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
261     return t2;
262
263   gcc_assert (code1 == code2);
264
265   switch (code1)
266     {
267     case POINTER_TYPE:
268       /* For two pointers, do this recursively on the target type.  */
269       {
270         tree pointed_to_1 = TREE_TYPE (t1);
271         tree pointed_to_2 = TREE_TYPE (t2);
272         tree target = composite_type (pointed_to_1, pointed_to_2);
273         t1 = build_pointer_type (target);
274         t1 = build_type_attribute_variant (t1, attributes);
275         return qualify_type (t1, t2);
276       }
277
278     case ARRAY_TYPE:
279       {
280         tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
281         
282         /* We should not have any type quals on arrays at all.  */
283         gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
284         
285         /* Save space: see if the result is identical to one of the args.  */
286         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
287           return build_type_attribute_variant (t1, attributes);
288         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
289           return build_type_attribute_variant (t2, attributes);
290         
291         if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
292           return build_type_attribute_variant (t1, attributes);
293         if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
294           return build_type_attribute_variant (t2, attributes);
295         
296         /* Merge the element types, and have a size if either arg has one.  */
297         t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
298         return build_type_attribute_variant (t1, attributes);
299       }
300
301     case FUNCTION_TYPE:
302       /* Function types: prefer the one that specified arg types.
303          If both do, merge the arg types.  Also merge the return types.  */
304       {
305         tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
306         tree p1 = TYPE_ARG_TYPES (t1);
307         tree p2 = TYPE_ARG_TYPES (t2);
308         int len;
309         tree newargs, n;
310         int i;
311
312         /* Save space: see if the result is identical to one of the args.  */
313         if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
314           return build_type_attribute_variant (t1, attributes);
315         if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
316           return build_type_attribute_variant (t2, attributes);
317
318         /* Simple way if one arg fails to specify argument types.  */
319         if (TYPE_ARG_TYPES (t1) == 0)
320          {
321             t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
322             t1 = build_type_attribute_variant (t1, attributes);
323             return qualify_type (t1, t2);
324          }
325         if (TYPE_ARG_TYPES (t2) == 0)
326          {
327            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
328            t1 = build_type_attribute_variant (t1, attributes);
329            return qualify_type (t1, t2);
330          }
331
332         /* If both args specify argument types, we must merge the two
333            lists, argument by argument.  */
334         /* Tell global_bindings_p to return false so that variable_size
335            doesn't abort on VLAs in parameter types.  */
336         c_override_global_bindings_to_false = true;
337
338         len = list_length (p1);
339         newargs = 0;
340
341         for (i = 0; i < len; i++)
342           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
343
344         n = newargs;
345
346         for (; p1;
347              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
348           {
349             /* A null type means arg type is not specified.
350                Take whatever the other function type has.  */
351             if (TREE_VALUE (p1) == 0)
352               {
353                 TREE_VALUE (n) = TREE_VALUE (p2);
354                 goto parm_done;
355               }
356             if (TREE_VALUE (p2) == 0)
357               {
358                 TREE_VALUE (n) = TREE_VALUE (p1);
359                 goto parm_done;
360               }
361
362             /* Given  wait (union {union wait *u; int *i} *)
363                and  wait (union wait *),
364                prefer  union wait *  as type of parm.  */
365             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
366                 && TREE_VALUE (p1) != TREE_VALUE (p2))
367               {
368                 tree memb;
369                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
370                      memb; memb = TREE_CHAIN (memb))
371                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
372                     {
373                       TREE_VALUE (n) = TREE_VALUE (p2);
374                       if (pedantic)
375                         pedwarn ("function types not truly compatible in ISO C");
376                       goto parm_done;
377                     }
378               }
379             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
380                 && TREE_VALUE (p2) != TREE_VALUE (p1))
381               {
382                 tree memb;
383                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
384                      memb; memb = TREE_CHAIN (memb))
385                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
386                     {
387                       TREE_VALUE (n) = TREE_VALUE (p1);
388                       if (pedantic)
389                         pedwarn ("function types not truly compatible in ISO C");
390                       goto parm_done;
391                     }
392               }
393             TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
394           parm_done: ;
395           }
396
397         c_override_global_bindings_to_false = false;
398         t1 = build_function_type (valtype, newargs);
399         t1 = qualify_type (t1, t2);
400         /* ... falls through ...  */
401       }
402
403     default:
404       return build_type_attribute_variant (t1, attributes);
405     }
406
407 }
408
409 /* Return the type of a conditional expression between pointers to
410    possibly differently qualified versions of compatible types.
411
412    We assume that comp_target_types has already been done and returned
413    nonzero; if that isn't so, this may crash.  */
414
415 static tree
416 common_pointer_type (tree t1, tree t2)
417 {
418   tree attributes;
419   tree pointed_to_1;
420   tree pointed_to_2;
421   tree target;
422
423   /* Save time if the two types are the same.  */
424
425   if (t1 == t2) return t1;
426
427   /* If one type is nonsense, use the other.  */
428   if (t1 == error_mark_node)
429     return t2;
430   if (t2 == error_mark_node)
431     return t1;
432
433   gcc_assert (TREE_CODE (t1) == POINTER_TYPE
434               && TREE_CODE (t2) == POINTER_TYPE);
435
436   /* Merge the attributes.  */
437   attributes = targetm.merge_type_attributes (t1, t2);
438
439   /* Find the composite type of the target types, and combine the
440      qualifiers of the two types' targets.  */
441   pointed_to_1 = TREE_TYPE (t1);
442   pointed_to_2 = TREE_TYPE (t2);
443   target = composite_type (TYPE_MAIN_VARIANT (pointed_to_1),
444                            TYPE_MAIN_VARIANT (pointed_to_2));
445   t1 = build_pointer_type (c_build_qualified_type
446                            (target,
447                             TYPE_QUALS (pointed_to_1) |
448                             TYPE_QUALS (pointed_to_2)));
449   return build_type_attribute_variant (t1, attributes);
450 }
451
452 /* Return the common type for two arithmetic types under the usual
453    arithmetic conversions.  The default conversions have already been
454    applied, and enumerated types converted to their compatible integer
455    types.  The resulting type is unqualified and has no attributes.
456
457    This is the type for the result of most arithmetic operations
458    if the operands have the given two types.  */
459
460 tree
461 common_type (tree t1, tree t2)
462 {
463   enum tree_code code1;
464   enum tree_code code2;
465
466   /* If one type is nonsense, use the other.  */
467   if (t1 == error_mark_node)
468     return t2;
469   if (t2 == error_mark_node)
470     return t1;
471
472   if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
473     t1 = TYPE_MAIN_VARIANT (t1);
474
475   if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
476     t2 = TYPE_MAIN_VARIANT (t2);
477
478   if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
479     t1 = build_type_attribute_variant (t1, NULL_TREE);
480
481   if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
482     t2 = build_type_attribute_variant (t2, NULL_TREE);
483
484   /* Save time if the two types are the same.  */
485
486   if (t1 == t2) return t1;
487
488   code1 = TREE_CODE (t1);
489   code2 = TREE_CODE (t2);
490
491   gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
492               || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
493   gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
494               || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
495
496   /* If one type is a vector type, return that type.  (How the usual
497      arithmetic conversions apply to the vector types extension is not
498      precisely specified.)  */
499   if (code1 == VECTOR_TYPE)
500     return t1;
501
502   if (code2 == VECTOR_TYPE)
503     return t2;
504
505   /* If one type is complex, form the common type of the non-complex
506      components, then make that complex.  Use T1 or T2 if it is the
507      required type.  */
508   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
509     {
510       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
511       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
512       tree subtype = common_type (subtype1, subtype2);
513
514       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
515         return t1;
516       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
517         return t2;
518       else
519         return build_complex_type (subtype);
520     }
521
522   /* If only one is real, use it as the result.  */
523
524   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
525     return t1;
526
527   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
528     return t2;
529
530   /* Both real or both integers; use the one with greater precision.  */
531
532   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
533     return t1;
534   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
535     return t2;
536
537   /* Same precision.  Prefer long longs to longs to ints when the
538      same precision, following the C99 rules on integer type rank
539      (which are equivalent to the C90 rules for C90 types).  */
540
541   if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
542       || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
543     return long_long_unsigned_type_node;
544
545   if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
546       || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
547     {
548       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
549         return long_long_unsigned_type_node;
550       else
551         return long_long_integer_type_node;
552     }
553
554   if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
555       || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
556     return long_unsigned_type_node;
557
558   if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
559       || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
560     {
561       /* But preserve unsignedness from the other type,
562          since long cannot hold all the values of an unsigned int.  */
563       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
564         return long_unsigned_type_node;
565       else
566         return long_integer_type_node;
567     }
568
569   /* Likewise, prefer long double to double even if same size.  */
570   if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
571       || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
572     return long_double_type_node;
573
574   /* Otherwise prefer the unsigned one.  */
575
576   if (TYPE_UNSIGNED (t1))
577     return t1;
578   else
579     return t2;
580 }
581 \f
582 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
583    or various other operations.  Return 2 if they are compatible
584    but a warning may be needed if you use them together.  */
585
586 int
587 comptypes (tree type1, tree type2)
588 {
589   tree t1 = type1;
590   tree t2 = type2;
591   int attrval, val;
592
593   /* Suppress errors caused by previously reported errors.  */
594
595   if (t1 == t2 || !t1 || !t2
596       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
597     return 1;
598
599   /* If either type is the internal version of sizetype, return the
600      language version.  */
601   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
602       && TYPE_ORIG_SIZE_TYPE (t1))
603     t1 = TYPE_ORIG_SIZE_TYPE (t1);
604
605   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
606       && TYPE_ORIG_SIZE_TYPE (t2))
607     t2 = TYPE_ORIG_SIZE_TYPE (t2);
608
609
610   /* Enumerated types are compatible with integer types, but this is
611      not transitive: two enumerated types in the same translation unit
612      are compatible with each other only if they are the same type.  */
613
614   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
615     t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
616   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
617     t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
618
619   if (t1 == t2)
620     return 1;
621
622   /* Different classes of types can't be compatible.  */
623
624   if (TREE_CODE (t1) != TREE_CODE (t2))
625     return 0;
626
627   /* Qualifiers must match. C99 6.7.3p9 */
628
629   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
630     return 0;
631
632   /* Allow for two different type nodes which have essentially the same
633      definition.  Note that we already checked for equality of the type
634      qualifiers (just above).  */
635
636   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
637     return 1;
638
639   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
640   if (!(attrval = targetm.comp_type_attributes (t1, t2)))
641      return 0;
642
643   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
644   val = 0;
645
646   switch (TREE_CODE (t1))
647     {
648     case POINTER_TYPE:
649       /* We must give ObjC the first crack at comparing pointers, since
650            protocol qualifiers may be involved.  */
651       if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
652         break;
653       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
654              ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
655       break;
656
657     case FUNCTION_TYPE:
658       val = function_types_compatible_p (t1, t2);
659       break;
660
661     case ARRAY_TYPE:
662       {
663         tree d1 = TYPE_DOMAIN (t1);
664         tree d2 = TYPE_DOMAIN (t2);
665         bool d1_variable, d2_variable;
666         bool d1_zero, d2_zero;
667         val = 1;
668
669         /* Target types must match incl. qualifiers.  */
670         if (TREE_TYPE (t1) != TREE_TYPE (t2)
671             && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
672           return 0;
673
674         /* Sizes must match unless one is missing or variable.  */
675         if (d1 == 0 || d2 == 0 || d1 == d2)
676           break;
677
678         d1_zero = !TYPE_MAX_VALUE (d1);
679         d2_zero = !TYPE_MAX_VALUE (d2);
680
681         d1_variable = (!d1_zero
682                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
683                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
684         d2_variable = (!d2_zero
685                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
686                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
687
688         if (d1_variable || d2_variable)
689           break;
690         if (d1_zero && d2_zero)
691           break;
692         if (d1_zero || d2_zero
693             || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
694             || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
695           val = 0;
696
697         break;
698       }
699
700     case RECORD_TYPE:
701       /* We are dealing with two distinct structs.  In assorted Objective-C
702          corner cases, however, these can still be deemed equivalent.  */
703       if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
704         val = 1;
705
706     case ENUMERAL_TYPE:
707     case UNION_TYPE:
708       if (val != 1 && !same_translation_unit_p (t1, t2))
709         val = tagged_types_tu_compatible_p (t1, t2);
710       break;
711
712     case VECTOR_TYPE:
713       val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
714             && comptypes (TREE_TYPE (t1), TREE_TYPE (t2));
715       break;
716
717     default:
718       break;
719     }
720   return attrval == 2 && val == 1 ? 2 : val;
721 }
722
723 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
724    ignoring their qualifiers.  REFLEXIVE is only used by ObjC - set it
725    to 1 or 0 depending if the check of the pointer types is meant to
726    be reflexive or not (typically, assignments are not reflexive,
727    while comparisons are reflexive).
728 */
729
730 static int
731 comp_target_types (tree ttl, tree ttr, int reflexive)
732 {
733   int val;
734
735   /* Give objc_comptypes a crack at letting these types through.  */
736   if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
737     return val;
738
739   val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
740                    TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
741
742   if (val == 2 && pedantic)
743     pedwarn ("types are not quite compatible");
744   return val;
745 }
746 \f
747 /* Subroutines of `comptypes'.  */
748
749 /* Determine whether two trees derive from the same translation unit.
750    If the CONTEXT chain ends in a null, that tree's context is still
751    being parsed, so if two trees have context chains ending in null,
752    they're in the same translation unit.  */
753 int
754 same_translation_unit_p (tree t1, tree t2)
755 {
756   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
757     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
758       {
759       case tcc_declaration:
760         t1 = DECL_CONTEXT (t1); break;
761       case tcc_type:
762         t1 = TYPE_CONTEXT (t1); break;
763       case tcc_exceptional:
764         t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
765       default: gcc_unreachable ();
766       }
767
768   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
769     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
770       {
771       case tcc_declaration:
772         t2 = DECL_CONTEXT (t2); break;
773       case tcc_type:
774         t2 = TYPE_CONTEXT (t2); break;
775       case tcc_exceptional:
776         t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
777       default: gcc_unreachable ();
778       }
779
780   return t1 == t2;
781 }
782
783 /* The C standard says that two structures in different translation
784    units are compatible with each other only if the types of their
785    fields are compatible (among other things).  So, consider two copies
786    of this structure:  */
787
788 struct tagged_tu_seen {
789   const struct tagged_tu_seen * next;
790   tree t1;
791   tree t2;
792 };
793
794 /* Can they be compatible with each other?  We choose to break the
795    recursion by allowing those types to be compatible.  */
796
797 static const struct tagged_tu_seen * tagged_tu_seen_base;
798
799 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
800    compatible.  If the two types are not the same (which has been
801    checked earlier), this can only happen when multiple translation
802    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
803    rules.  */
804
805 static int
806 tagged_types_tu_compatible_p (tree t1, tree t2)
807 {
808   tree s1, s2;
809   bool needs_warning = false;
810
811   /* We have to verify that the tags of the types are the same.  This
812      is harder than it looks because this may be a typedef, so we have
813      to go look at the original type.  It may even be a typedef of a
814      typedef...
815      In the case of compiler-created builtin structs the TYPE_DECL
816      may be a dummy, with no DECL_ORIGINAL_TYPE.  Don't fault.  */
817   while (TYPE_NAME (t1)
818          && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
819          && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
820     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
821
822   while (TYPE_NAME (t2)
823          && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
824          && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
825     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
826
827   /* C90 didn't have the requirement that the two tags be the same.  */
828   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
829     return 0;
830
831   /* C90 didn't say what happened if one or both of the types were
832      incomplete; we choose to follow C99 rules here, which is that they
833      are compatible.  */
834   if (TYPE_SIZE (t1) == NULL
835       || TYPE_SIZE (t2) == NULL)
836     return 1;
837
838   {
839     const struct tagged_tu_seen * tts_i;
840     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
841       if (tts_i->t1 == t1 && tts_i->t2 == t2)
842         return 1;
843   }
844
845   switch (TREE_CODE (t1))
846     {
847     case ENUMERAL_TYPE:
848       {
849
850         /* Speed up the case where the type values are in the same order.  */
851         tree tv1 = TYPE_VALUES (t1);
852         tree tv2 = TYPE_VALUES (t2);
853
854         if (tv1 == tv2)
855           return 1;
856
857         for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
858           {
859             if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
860               break;
861             if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
862               return 0;
863           }
864
865         if (tv1 == NULL_TREE && tv2 == NULL_TREE)
866           return 1;
867         if (tv1 == NULL_TREE || tv2 == NULL_TREE)
868           return 0;
869
870         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
871           return 0;
872
873         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
874           {
875             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
876             if (s2 == NULL
877                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
878               return 0;
879           }
880         return 1;
881       }
882
883     case UNION_TYPE:
884       {
885         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
886           return 0;
887
888         for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
889           {
890             bool ok = false;
891             struct tagged_tu_seen tts;
892
893             tts.next = tagged_tu_seen_base;
894             tts.t1 = t1;
895             tts.t2 = t2;
896             tagged_tu_seen_base = &tts;
897
898             if (DECL_NAME (s1) != NULL)
899               for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
900                 if (DECL_NAME (s1) == DECL_NAME (s2))
901                   {
902                     int result;
903                     result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
904                     if (result == 0)
905                       break;
906                     if (result == 2)
907                       needs_warning = true;
908
909                     if (TREE_CODE (s1) == FIELD_DECL
910                         && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
911                                              DECL_FIELD_BIT_OFFSET (s2)) != 1)
912                       break;
913
914                     ok = true;
915                     break;
916                   }
917             tagged_tu_seen_base = tts.next;
918             if (!ok)
919               return 0;
920           }
921         return needs_warning ? 2 : 1;
922       }
923
924     case RECORD_TYPE:
925       {
926         struct tagged_tu_seen tts;
927
928         tts.next = tagged_tu_seen_base;
929         tts.t1 = t1;
930         tts.t2 = t2;
931         tagged_tu_seen_base = &tts;
932
933         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
934              s1 && s2;
935              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
936           {
937             int result;
938             if (TREE_CODE (s1) != TREE_CODE (s2)
939                 || DECL_NAME (s1) != DECL_NAME (s2))
940               break;
941             result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
942             if (result == 0)
943               break;
944             if (result == 2)
945               needs_warning = true;
946
947             if (TREE_CODE (s1) == FIELD_DECL
948                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
949                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
950               break;
951           }
952         tagged_tu_seen_base = tts.next;
953         if (s1 && s2)
954           return 0;
955         return needs_warning ? 2 : 1;
956       }
957
958     default:
959       gcc_unreachable ();
960     }
961 }
962
963 /* Return 1 if two function types F1 and F2 are compatible.
964    If either type specifies no argument types,
965    the other must specify a fixed number of self-promoting arg types.
966    Otherwise, if one type specifies only the number of arguments,
967    the other must specify that number of self-promoting arg types.
968    Otherwise, the argument types must match.  */
969
970 static int
971 function_types_compatible_p (tree f1, tree f2)
972 {
973   tree args1, args2;
974   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
975   int val = 1;
976   int val1;
977   tree ret1, ret2;
978
979   ret1 = TREE_TYPE (f1);
980   ret2 = TREE_TYPE (f2);
981
982   /* 'volatile' qualifiers on a function's return type used to mean
983      the function is noreturn.  */
984   if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
985     pedwarn ("function return types not compatible due to %<volatile%>");
986   if (TYPE_VOLATILE (ret1))
987     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
988                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
989   if (TYPE_VOLATILE (ret2))
990     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
991                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
992   val = comptypes (ret1, ret2);
993   if (val == 0)
994     return 0;
995
996   args1 = TYPE_ARG_TYPES (f1);
997   args2 = TYPE_ARG_TYPES (f2);
998
999   /* An unspecified parmlist matches any specified parmlist
1000      whose argument types don't need default promotions.  */
1001
1002   if (args1 == 0)
1003     {
1004       if (!self_promoting_args_p (args2))
1005         return 0;
1006       /* If one of these types comes from a non-prototype fn definition,
1007          compare that with the other type's arglist.
1008          If they don't match, ask for a warning (but no error).  */
1009       if (TYPE_ACTUAL_ARG_TYPES (f1)
1010           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
1011         val = 2;
1012       return val;
1013     }
1014   if (args2 == 0)
1015     {
1016       if (!self_promoting_args_p (args1))
1017         return 0;
1018       if (TYPE_ACTUAL_ARG_TYPES (f2)
1019           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
1020         val = 2;
1021       return val;
1022     }
1023
1024   /* Both types have argument lists: compare them and propagate results.  */
1025   val1 = type_lists_compatible_p (args1, args2);
1026   return val1 != 1 ? val1 : val;
1027 }
1028
1029 /* Check two lists of types for compatibility,
1030    returning 0 for incompatible, 1 for compatible,
1031    or 2 for compatible with warning.  */
1032
1033 static int
1034 type_lists_compatible_p (tree args1, tree args2)
1035 {
1036   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1037   int val = 1;
1038   int newval = 0;
1039
1040   while (1)
1041     {
1042       if (args1 == 0 && args2 == 0)
1043         return val;
1044       /* If one list is shorter than the other,
1045          they fail to match.  */
1046       if (args1 == 0 || args2 == 0)
1047         return 0;
1048       /* A null pointer instead of a type
1049          means there is supposed to be an argument
1050          but nothing is specified about what type it has.
1051          So match anything that self-promotes.  */
1052       if (TREE_VALUE (args1) == 0)
1053         {
1054           if (c_type_promotes_to (TREE_VALUE (args2)) != TREE_VALUE (args2))
1055             return 0;
1056         }
1057       else if (TREE_VALUE (args2) == 0)
1058         {
1059           if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
1060             return 0;
1061         }
1062       /* If one of the lists has an error marker, ignore this arg.  */
1063       else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
1064                || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
1065         ;
1066       else if (!(newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
1067                                      TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
1068         {
1069           /* Allow  wait (union {union wait *u; int *i} *)
1070              and  wait (union wait *)  to be compatible.  */
1071           if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
1072               && (TYPE_NAME (TREE_VALUE (args1)) == 0
1073                   || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
1074               && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
1075               && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
1076                                      TYPE_SIZE (TREE_VALUE (args2))))
1077             {
1078               tree memb;
1079               for (memb = TYPE_FIELDS (TREE_VALUE (args1));
1080                    memb; memb = TREE_CHAIN (memb))
1081                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
1082                   break;
1083               if (memb == 0)
1084                 return 0;
1085             }
1086           else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
1087                    && (TYPE_NAME (TREE_VALUE (args2)) == 0
1088                        || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
1089                    && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
1090                    && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
1091                                           TYPE_SIZE (TREE_VALUE (args1))))
1092             {
1093               tree memb;
1094               for (memb = TYPE_FIELDS (TREE_VALUE (args2));
1095                    memb; memb = TREE_CHAIN (memb))
1096                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
1097                   break;
1098               if (memb == 0)
1099                 return 0;
1100             }
1101           else
1102             return 0;
1103         }
1104
1105       /* comptypes said ok, but record if it said to warn.  */
1106       if (newval > val)
1107         val = newval;
1108
1109       args1 = TREE_CHAIN (args1);
1110       args2 = TREE_CHAIN (args2);
1111     }
1112 }
1113 \f
1114 /* Compute the size to increment a pointer by.  */
1115
1116 tree
1117 c_size_in_bytes (tree type)
1118 {
1119   enum tree_code code = TREE_CODE (type);
1120
1121   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1122     return size_one_node;
1123
1124   if (!COMPLETE_OR_VOID_TYPE_P (type))
1125     {
1126       error ("arithmetic on pointer to an incomplete type");
1127       return size_one_node;
1128     }
1129
1130   /* Convert in case a char is more than one unit.  */
1131   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1132                      size_int (TYPE_PRECISION (char_type_node)
1133                                / BITS_PER_UNIT));
1134 }
1135 \f
1136 /* Return either DECL or its known constant value (if it has one).  */
1137
1138 tree
1139 decl_constant_value (tree decl)
1140 {
1141   if (/* Don't change a variable array bound or initial value to a constant
1142          in a place where a variable is invalid.  Note that DECL_INITIAL
1143          isn't valid for a PARM_DECL.  */
1144       current_function_decl != 0
1145       && TREE_CODE (decl) != PARM_DECL
1146       && !TREE_THIS_VOLATILE (decl)
1147       && TREE_READONLY (decl)
1148       && DECL_INITIAL (decl) != 0
1149       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1150       /* This is invalid if initial value is not constant.
1151          If it has either a function call, a memory reference,
1152          or a variable, then re-evaluating it could give different results.  */
1153       && TREE_CONSTANT (DECL_INITIAL (decl))
1154       /* Check for cases where this is sub-optimal, even though valid.  */
1155       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1156     return DECL_INITIAL (decl);
1157   return decl;
1158 }
1159
1160 /* Return either DECL or its known constant value (if it has one), but
1161    return DECL if pedantic or DECL has mode BLKmode.  This is for
1162    bug-compatibility with the old behavior of decl_constant_value
1163    (before GCC 3.0); every use of this function is a bug and it should
1164    be removed before GCC 3.1.  It is not appropriate to use pedantic
1165    in a way that affects optimization, and BLKmode is probably not the
1166    right test for avoiding misoptimizations either.  */
1167
1168 static tree
1169 decl_constant_value_for_broken_optimization (tree decl)
1170 {
1171   if (pedantic || DECL_MODE (decl) == BLKmode)
1172     return decl;
1173   else
1174     return decl_constant_value (decl);
1175 }
1176
1177
1178 /* Perform the default conversion of arrays and functions to pointers.
1179    Return the result of converting EXP.  For any other expression, just
1180    return EXP.  */
1181
1182 static tree
1183 default_function_array_conversion (tree exp)
1184 {
1185   tree orig_exp;
1186   tree type = TREE_TYPE (exp);
1187   enum tree_code code = TREE_CODE (type);
1188   int not_lvalue = 0;
1189
1190   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1191      an lvalue.
1192
1193      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1194      to integer and cause infinite recursion.  */
1195   orig_exp = exp;
1196   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1197          || (TREE_CODE (exp) == NOP_EXPR
1198              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1199     {
1200       if (TREE_CODE (exp) == NON_LVALUE_EXPR)
1201         not_lvalue = 1;
1202       exp = TREE_OPERAND (exp, 0);
1203     }
1204
1205   if (TREE_NO_WARNING (orig_exp))
1206     TREE_NO_WARNING (exp) = 1;
1207
1208   if (code == FUNCTION_TYPE)
1209     {
1210       return build_unary_op (ADDR_EXPR, exp, 0);
1211     }
1212   if (code == ARRAY_TYPE)
1213     {
1214       tree adr;
1215       tree restype = TREE_TYPE (type);
1216       tree ptrtype;
1217       int constp = 0;
1218       int volatilep = 0;
1219       int lvalue_array_p;
1220
1221       if (REFERENCE_CLASS_P (exp) || DECL_P (exp))
1222         {
1223           constp = TREE_READONLY (exp);
1224           volatilep = TREE_THIS_VOLATILE (exp);
1225         }
1226
1227       if (TYPE_QUALS (type) || constp || volatilep)
1228         restype
1229           = c_build_qualified_type (restype,
1230                                     TYPE_QUALS (type)
1231                                     | (constp * TYPE_QUAL_CONST)
1232                                     | (volatilep * TYPE_QUAL_VOLATILE));
1233
1234       if (TREE_CODE (exp) == INDIRECT_REF)
1235         return convert (build_pointer_type (restype),
1236                         TREE_OPERAND (exp, 0));
1237
1238       if (TREE_CODE (exp) == COMPOUND_EXPR)
1239         {
1240           tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1241           return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1242                          TREE_OPERAND (exp, 0), op1);
1243         }
1244
1245       lvalue_array_p = !not_lvalue && lvalue_p (exp);
1246       if (!flag_isoc99 && !lvalue_array_p)
1247         {
1248           /* Before C99, non-lvalue arrays do not decay to pointers.
1249              Normally, using such an array would be invalid; but it can
1250              be used correctly inside sizeof or as a statement expression.
1251              Thus, do not give an error here; an error will result later.  */
1252           return exp;
1253         }
1254
1255       ptrtype = build_pointer_type (restype);
1256
1257       if (TREE_CODE (exp) == VAR_DECL)
1258         {
1259           /* We are making an ADDR_EXPR of ptrtype.  This is a valid
1260              ADDR_EXPR because it's the best way of representing what
1261              happens in C when we take the address of an array and place
1262              it in a pointer to the element type.  */
1263           adr = build1 (ADDR_EXPR, ptrtype, exp);
1264           if (!c_mark_addressable (exp))
1265             return error_mark_node;
1266           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1267           return adr;
1268         }
1269       /* This way is better for a COMPONENT_REF since it can
1270          simplify the offset for a component.  */
1271       adr = build_unary_op (ADDR_EXPR, exp, 1);
1272       return convert (ptrtype, adr);
1273     }
1274   return exp;
1275 }
1276
1277 /* Perform default promotions for C data used in expressions.
1278    Arrays and functions are converted to pointers;
1279    enumeral types or short or char, to int.
1280    In addition, manifest constants symbols are replaced by their values.  */
1281
1282 tree
1283 default_conversion (tree exp)
1284 {
1285   tree orig_exp;
1286   tree type = TREE_TYPE (exp);
1287   enum tree_code code = TREE_CODE (type);
1288
1289   if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
1290     return default_function_array_conversion (exp);
1291
1292   /* Constants can be used directly unless they're not loadable.  */
1293   if (TREE_CODE (exp) == CONST_DECL)
1294     exp = DECL_INITIAL (exp);
1295
1296   /* Replace a nonvolatile const static variable with its value unless
1297      it is an array, in which case we must be sure that taking the
1298      address of the array produces consistent results.  */
1299   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1300     {
1301       exp = decl_constant_value_for_broken_optimization (exp);
1302       type = TREE_TYPE (exp);
1303     }
1304
1305   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1306      an lvalue.
1307
1308      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1309      to integer and cause infinite recursion.  */
1310   orig_exp = exp;
1311   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1312          || (TREE_CODE (exp) == NOP_EXPR
1313              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1314     exp = TREE_OPERAND (exp, 0);
1315
1316   if (TREE_NO_WARNING (orig_exp))
1317     TREE_NO_WARNING (exp) = 1;
1318
1319   /* Normally convert enums to int,
1320      but convert wide enums to something wider.  */
1321   if (code == ENUMERAL_TYPE)
1322     {
1323       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1324                                           TYPE_PRECISION (integer_type_node)),
1325                                      ((TYPE_PRECISION (type)
1326                                        >= TYPE_PRECISION (integer_type_node))
1327                                       && TYPE_UNSIGNED (type)));
1328
1329       return convert (type, exp);
1330     }
1331
1332   if (TREE_CODE (exp) == COMPONENT_REF
1333       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1334       /* If it's thinner than an int, promote it like a
1335          c_promoting_integer_type_p, otherwise leave it alone.  */
1336       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1337                                TYPE_PRECISION (integer_type_node)))
1338     return convert (integer_type_node, exp);
1339
1340   if (c_promoting_integer_type_p (type))
1341     {
1342       /* Preserve unsignedness if not really getting any wider.  */
1343       if (TYPE_UNSIGNED (type)
1344           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1345         return convert (unsigned_type_node, exp);
1346
1347       return convert (integer_type_node, exp);
1348     }
1349
1350   if (code == VOID_TYPE)
1351     {
1352       error ("void value not ignored as it ought to be");
1353       return error_mark_node;
1354     }
1355   return exp;
1356 }
1357 \f
1358 /* Look up COMPONENT in a structure or union DECL.
1359
1360    If the component name is not found, returns NULL_TREE.  Otherwise,
1361    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1362    stepping down the chain to the component, which is in the last
1363    TREE_VALUE of the list.  Normally the list is of length one, but if
1364    the component is embedded within (nested) anonymous structures or
1365    unions, the list steps down the chain to the component.  */
1366
1367 static tree
1368 lookup_field (tree decl, tree component)
1369 {
1370   tree type = TREE_TYPE (decl);
1371   tree field;
1372
1373   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1374      to the field elements.  Use a binary search on this array to quickly
1375      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1376      will always be set for structures which have many elements.  */
1377
1378   if (TYPE_LANG_SPECIFIC (type))
1379     {
1380       int bot, top, half;
1381       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1382
1383       field = TYPE_FIELDS (type);
1384       bot = 0;
1385       top = TYPE_LANG_SPECIFIC (type)->s->len;
1386       while (top - bot > 1)
1387         {
1388           half = (top - bot + 1) >> 1;
1389           field = field_array[bot+half];
1390
1391           if (DECL_NAME (field) == NULL_TREE)
1392             {
1393               /* Step through all anon unions in linear fashion.  */
1394               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1395                 {
1396                   field = field_array[bot++];
1397                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1398                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1399                     {
1400                       tree anon = lookup_field (field, component);
1401
1402                       if (anon)
1403                         return tree_cons (NULL_TREE, field, anon);
1404                     }
1405                 }
1406
1407               /* Entire record is only anon unions.  */
1408               if (bot > top)
1409                 return NULL_TREE;
1410
1411               /* Restart the binary search, with new lower bound.  */
1412               continue;
1413             }
1414
1415           if (DECL_NAME (field) == component)
1416             break;
1417           if (DECL_NAME (field) < component)
1418             bot += half;
1419           else
1420             top = bot + half;
1421         }
1422
1423       if (DECL_NAME (field_array[bot]) == component)
1424         field = field_array[bot];
1425       else if (DECL_NAME (field) != component)
1426         return NULL_TREE;
1427     }
1428   else
1429     {
1430       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1431         {
1432           if (DECL_NAME (field) == NULL_TREE
1433               && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1434                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1435             {
1436               tree anon = lookup_field (field, component);
1437
1438               if (anon)
1439                 return tree_cons (NULL_TREE, field, anon);
1440             }
1441
1442           if (DECL_NAME (field) == component)
1443             break;
1444         }
1445
1446       if (field == NULL_TREE)
1447         return NULL_TREE;
1448     }
1449
1450   return tree_cons (NULL_TREE, field, NULL_TREE);
1451 }
1452
1453 /* Make an expression to refer to the COMPONENT field of
1454    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1455
1456 tree
1457 build_component_ref (tree datum, tree component)
1458 {
1459   tree type = TREE_TYPE (datum);
1460   enum tree_code code = TREE_CODE (type);
1461   tree field = NULL;
1462   tree ref;
1463
1464   if (!objc_is_public (datum, component))
1465     return error_mark_node;
1466
1467   /* See if there is a field or component with name COMPONENT.  */
1468
1469   if (code == RECORD_TYPE || code == UNION_TYPE)
1470     {
1471       if (!COMPLETE_TYPE_P (type))
1472         {
1473           c_incomplete_type_error (NULL_TREE, type);
1474           return error_mark_node;
1475         }
1476
1477       field = lookup_field (datum, component);
1478
1479       if (!field)
1480         {
1481           error ("%qT has no member named %qs", type,
1482                  IDENTIFIER_POINTER (component));
1483           return error_mark_node;
1484         }
1485
1486       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1487          This might be better solved in future the way the C++ front
1488          end does it - by giving the anonymous entities each a
1489          separate name and type, and then have build_component_ref
1490          recursively call itself.  We can't do that here.  */
1491       do
1492         {
1493           tree subdatum = TREE_VALUE (field);
1494
1495           if (TREE_TYPE (subdatum) == error_mark_node)
1496             return error_mark_node;
1497
1498           ref = build3 (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum,
1499                         NULL_TREE);
1500           if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1501             TREE_READONLY (ref) = 1;
1502           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1503             TREE_THIS_VOLATILE (ref) = 1;
1504
1505           if (TREE_DEPRECATED (subdatum))
1506             warn_deprecated_use (subdatum);
1507
1508           datum = ref;
1509
1510           field = TREE_CHAIN (field);
1511         }
1512       while (field);
1513
1514       return ref;
1515     }
1516   else if (code != ERROR_MARK)
1517     error ("request for member %qs in something not a structure or union",
1518             IDENTIFIER_POINTER (component));
1519
1520   return error_mark_node;
1521 }
1522 \f
1523 /* Given an expression PTR for a pointer, return an expression
1524    for the value pointed to.
1525    ERRORSTRING is the name of the operator to appear in error messages.  */
1526
1527 tree
1528 build_indirect_ref (tree ptr, const char *errorstring)
1529 {
1530   tree pointer = default_conversion (ptr);
1531   tree type = TREE_TYPE (pointer);
1532
1533   if (TREE_CODE (type) == POINTER_TYPE)
1534     {
1535       if (TREE_CODE (pointer) == ADDR_EXPR
1536           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1537               == TREE_TYPE (type)))
1538         return TREE_OPERAND (pointer, 0);
1539       else
1540         {
1541           tree t = TREE_TYPE (type);
1542           tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1543
1544           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1545             {
1546               error ("dereferencing pointer to incomplete type");
1547               return error_mark_node;
1548             }
1549           if (VOID_TYPE_P (t) && skip_evaluation == 0)
1550             warning ("dereferencing %<void *%> pointer");
1551
1552           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1553              so that we get the proper error message if the result is used
1554              to assign to.  Also, &* is supposed to be a no-op.
1555              And ANSI C seems to specify that the type of the result
1556              should be the const type.  */
1557           /* A de-reference of a pointer to const is not a const.  It is valid
1558              to change it via some other pointer.  */
1559           TREE_READONLY (ref) = TYPE_READONLY (t);
1560           TREE_SIDE_EFFECTS (ref)
1561             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1562           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1563           return ref;
1564         }
1565     }
1566   else if (TREE_CODE (pointer) != ERROR_MARK)
1567     error ("invalid type argument of %qs", errorstring);
1568   return error_mark_node;
1569 }
1570
1571 /* This handles expressions of the form "a[i]", which denotes
1572    an array reference.
1573
1574    This is logically equivalent in C to *(a+i), but we may do it differently.
1575    If A is a variable or a member, we generate a primitive ARRAY_REF.
1576    This avoids forcing the array out of registers, and can work on
1577    arrays that are not lvalues (for example, members of structures returned
1578    by functions).  */
1579
1580 tree
1581 build_array_ref (tree array, tree index)
1582 {
1583   if (index == 0)
1584     {
1585       error ("subscript missing in array reference");
1586       return error_mark_node;
1587     }
1588
1589   if (TREE_TYPE (array) == error_mark_node
1590       || TREE_TYPE (index) == error_mark_node)
1591     return error_mark_node;
1592
1593   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
1594     {
1595       tree rval, type;
1596
1597       /* Subscripting with type char is likely to lose
1598          on a machine where chars are signed.
1599          So warn on any machine, but optionally.
1600          Don't warn for unsigned char since that type is safe.
1601          Don't warn for signed char because anyone who uses that
1602          must have done so deliberately.  */
1603       if (warn_char_subscripts
1604           && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1605         warning ("array subscript has type %<char%>");
1606
1607       /* Apply default promotions *after* noticing character types.  */
1608       index = default_conversion (index);
1609
1610       /* Require integer *after* promotion, for sake of enums.  */
1611       if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1612         {
1613           error ("array subscript is not an integer");
1614           return error_mark_node;
1615         }
1616
1617       /* An array that is indexed by a non-constant
1618          cannot be stored in a register; we must be able to do
1619          address arithmetic on its address.
1620          Likewise an array of elements of variable size.  */
1621       if (TREE_CODE (index) != INTEGER_CST
1622           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1623               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1624         {
1625           if (!c_mark_addressable (array))
1626             return error_mark_node;
1627         }
1628       /* An array that is indexed by a constant value which is not within
1629          the array bounds cannot be stored in a register either; because we
1630          would get a crash in store_bit_field/extract_bit_field when trying
1631          to access a non-existent part of the register.  */
1632       if (TREE_CODE (index) == INTEGER_CST
1633           && TYPE_DOMAIN (TREE_TYPE (array))
1634           && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
1635         {
1636           if (!c_mark_addressable (array))
1637             return error_mark_node;
1638         }
1639
1640       if (pedantic)
1641         {
1642           tree foo = array;
1643           while (TREE_CODE (foo) == COMPONENT_REF)
1644             foo = TREE_OPERAND (foo, 0);
1645           if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
1646             pedwarn ("ISO C forbids subscripting %<register%> array");
1647           else if (!flag_isoc99 && !lvalue_p (foo))
1648             pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1649         }
1650
1651       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1652       rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
1653       /* Array ref is const/volatile if the array elements are
1654          or if the array is.  */
1655       TREE_READONLY (rval)
1656         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1657             | TREE_READONLY (array));
1658       TREE_SIDE_EFFECTS (rval)
1659         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1660             | TREE_SIDE_EFFECTS (array));
1661       TREE_THIS_VOLATILE (rval)
1662         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1663             /* This was added by rms on 16 Nov 91.
1664                It fixes  vol struct foo *a;  a->elts[1]
1665                in an inline function.
1666                Hope it doesn't break something else.  */
1667             | TREE_THIS_VOLATILE (array));
1668       return require_complete_type (fold (rval));
1669     }
1670
1671   {
1672     tree ar = default_conversion (array);
1673     tree ind = default_conversion (index);
1674
1675     /* Do the same warning check as above, but only on the part that's
1676        syntactically the index and only if it is also semantically
1677        the index.  */
1678     if (warn_char_subscripts
1679         && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1680         && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1681       warning ("subscript has type %<char%>");
1682
1683     /* Put the integer in IND to simplify error checking.  */
1684     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1685       {
1686         tree temp = ar;
1687         ar = ind;
1688         ind = temp;
1689       }
1690
1691     if (ar == error_mark_node)
1692       return ar;
1693
1694     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1695         || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1696       {
1697         error ("subscripted value is neither array nor pointer");
1698         return error_mark_node;
1699       }
1700     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1701       {
1702         error ("array subscript is not an integer");
1703         return error_mark_node;
1704       }
1705
1706     return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1707                                "array indexing");
1708   }
1709 }
1710 \f
1711 /* Build an external reference to identifier ID.  FUN indicates
1712    whether this will be used for a function call.  */
1713 tree
1714 build_external_ref (tree id, int fun)
1715 {
1716   tree ref;
1717   tree decl = lookup_name (id);
1718   tree objc_ivar = objc_lookup_ivar (id);
1719
1720   if (decl && decl != error_mark_node)
1721     {
1722       /* Properly declared variable or function reference.  */
1723       if (!objc_ivar)
1724         ref = decl;
1725       else if (decl != objc_ivar && !DECL_FILE_SCOPE_P (decl))
1726         {
1727           warning ("local declaration of %qs hides instance variable",
1728                    IDENTIFIER_POINTER (id));
1729           ref = decl;
1730         }
1731       else
1732         ref = objc_ivar;
1733     }
1734   else if (objc_ivar)
1735     ref = objc_ivar;
1736   else if (fun)
1737     /* Implicit function declaration.  */
1738     ref = implicitly_declare (id);
1739   else if (decl == error_mark_node)
1740     /* Don't complain about something that's already been
1741        complained about.  */
1742     return error_mark_node;
1743   else
1744     {
1745       undeclared_variable (id);
1746       return error_mark_node;
1747     }
1748
1749   if (TREE_TYPE (ref) == error_mark_node)
1750     return error_mark_node;
1751
1752   if (TREE_DEPRECATED (ref))
1753     warn_deprecated_use (ref);
1754
1755   if (!skip_evaluation)
1756     assemble_external (ref);
1757   TREE_USED (ref) = 1;
1758
1759   if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
1760     {
1761       if (!in_sizeof && !in_typeof)
1762         C_DECL_USED (ref) = 1;
1763       else if (DECL_INITIAL (ref) == 0
1764                && DECL_EXTERNAL (ref)
1765                && !TREE_PUBLIC (ref))
1766         record_maybe_used_decl (ref);
1767     }
1768
1769   if (TREE_CODE (ref) == CONST_DECL)
1770     {
1771       ref = DECL_INITIAL (ref);
1772       TREE_CONSTANT (ref) = 1;
1773       TREE_INVARIANT (ref) = 1;
1774     }
1775   else if (current_function_decl != 0
1776            && !DECL_FILE_SCOPE_P (current_function_decl)
1777            && (TREE_CODE (ref) == VAR_DECL
1778                || TREE_CODE (ref) == PARM_DECL
1779                || TREE_CODE (ref) == FUNCTION_DECL))
1780     {
1781       tree context = decl_function_context (ref);
1782
1783       if (context != 0 && context != current_function_decl)
1784         DECL_NONLOCAL (ref) = 1;
1785     }
1786
1787   return ref;
1788 }
1789
1790 /* Record details of decls possibly used inside sizeof or typeof.  */
1791 struct maybe_used_decl
1792 {
1793   /* The decl.  */
1794   tree decl;
1795   /* The level seen at (in_sizeof + in_typeof).  */
1796   int level;
1797   /* The next one at this level or above, or NULL.  */
1798   struct maybe_used_decl *next;
1799 };
1800
1801 static struct maybe_used_decl *maybe_used_decls;
1802
1803 /* Record that DECL, an undefined static function reference seen
1804    inside sizeof or typeof, might be used if the operand of sizeof is
1805    a VLA type or the operand of typeof is a variably modified
1806    type.  */
1807
1808 void
1809 record_maybe_used_decl (tree decl)
1810 {
1811   struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
1812   t->decl = decl;
1813   t->level = in_sizeof + in_typeof;
1814   t->next = maybe_used_decls;
1815   maybe_used_decls = t;
1816 }
1817
1818 /* Pop the stack of decls possibly used inside sizeof or typeof.  If
1819    USED is false, just discard them.  If it is true, mark them used
1820    (if no longer inside sizeof or typeof) or move them to the next
1821    level up (if still inside sizeof or typeof).  */
1822
1823 void
1824 pop_maybe_used (bool used)
1825 {
1826   struct maybe_used_decl *p = maybe_used_decls;
1827   int cur_level = in_sizeof + in_typeof;
1828   while (p && p->level > cur_level)
1829     {
1830       if (used)
1831         {
1832           if (cur_level == 0)
1833             C_DECL_USED (p->decl) = 1;
1834           else
1835             p->level = cur_level;
1836         }
1837       p = p->next;
1838     }
1839   if (!used || cur_level == 0)
1840     maybe_used_decls = p;
1841 }
1842
1843 /* Return the result of sizeof applied to EXPR.  */
1844
1845 struct c_expr
1846 c_expr_sizeof_expr (struct c_expr expr)
1847 {
1848   struct c_expr ret;
1849   if (expr.value == error_mark_node)
1850     {
1851       ret.value = error_mark_node;
1852       ret.original_code = ERROR_MARK;
1853       pop_maybe_used (false);
1854     }
1855   else
1856     {
1857       ret.value = c_sizeof (TREE_TYPE (expr.value));
1858       ret.original_code = ERROR_MARK;
1859       pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value)));
1860     }
1861   return ret;
1862 }
1863
1864 /* Return the result of sizeof applied to T, a structure for the type
1865    name passed to sizeof (rather than the type itself).  */
1866
1867 struct c_expr
1868 c_expr_sizeof_type (struct c_type_name *t)
1869 {
1870   tree type;
1871   struct c_expr ret;
1872   type = groktypename (t);
1873   ret.value = c_sizeof (type);
1874   ret.original_code = ERROR_MARK;
1875   pop_maybe_used (C_TYPE_VARIABLE_SIZE (type));
1876   return ret;
1877 }
1878
1879 /* Build a function call to function FUNCTION with parameters PARAMS.
1880    PARAMS is a list--a chain of TREE_LIST nodes--in which the
1881    TREE_VALUE of each node is a parameter-expression.
1882    FUNCTION's data type may be a function type or a pointer-to-function.  */
1883
1884 tree
1885 build_function_call (tree function, tree params)
1886 {
1887   tree fntype, fundecl = 0;
1888   tree coerced_params;
1889   tree name = NULL_TREE, result;
1890   tree tem;
1891
1892   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1893   STRIP_TYPE_NOPS (function);
1894
1895   /* Convert anything with function type to a pointer-to-function.  */
1896   if (TREE_CODE (function) == FUNCTION_DECL)
1897     {
1898       name = DECL_NAME (function);
1899
1900       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1901          (because calling an inline function does not mean the function
1902          needs to be separately compiled).  */
1903       fntype = build_type_variant (TREE_TYPE (function),
1904                                    TREE_READONLY (function),
1905                                    TREE_THIS_VOLATILE (function));
1906       fundecl = function;
1907       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1908     }
1909   else
1910     function = default_conversion (function);
1911
1912   fntype = TREE_TYPE (function);
1913
1914   if (TREE_CODE (fntype) == ERROR_MARK)
1915     return error_mark_node;
1916
1917   if (!(TREE_CODE (fntype) == POINTER_TYPE
1918         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1919     {
1920       error ("called object %qE is not a function", function);
1921       return error_mark_node;
1922     }
1923
1924   if (fundecl && TREE_THIS_VOLATILE (fundecl))
1925     current_function_returns_abnormally = 1;
1926
1927   /* fntype now gets the type of function pointed to.  */
1928   fntype = TREE_TYPE (fntype);
1929
1930   /* Check that the function is called through a compatible prototype.
1931      If it is not, replace the call by a trap, wrapped up in a compound
1932      expression if necessary.  This has the nice side-effect to prevent
1933      the tree-inliner from generating invalid assignment trees which may
1934      blow up in the RTL expander later.
1935
1936      ??? This doesn't work for Objective-C because objc_comptypes
1937      refuses to compare function prototypes, yet the compiler appears
1938      to build calls that are flagged as invalid by C's comptypes.  */
1939   if (!c_dialect_objc ()
1940       && TREE_CODE (function) == NOP_EXPR
1941       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
1942       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
1943       && !comptypes (fntype, TREE_TYPE (tem)))
1944     {
1945       tree return_type = TREE_TYPE (fntype);
1946       tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
1947                                        NULL_TREE);
1948
1949       /* This situation leads to run-time undefined behavior.  We can't,
1950          therefore, simply error unless we can prove that all possible
1951          executions of the program must execute the code.  */
1952       warning ("function called through a non-compatible type");
1953
1954       /* We can, however, treat "undefined" any way we please.
1955          Call abort to encourage the user to fix the program.  */
1956       inform ("if this code is reached, the program will abort");
1957
1958       if (VOID_TYPE_P (return_type))
1959         return trap;
1960       else
1961         {
1962           tree rhs;
1963
1964           if (AGGREGATE_TYPE_P (return_type))
1965             rhs = build_compound_literal (return_type,
1966                                           build_constructor (return_type,
1967                                                              NULL_TREE));
1968           else
1969             rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
1970
1971           return build2 (COMPOUND_EXPR, return_type, trap, rhs);
1972         }
1973     }
1974
1975   /* Convert the parameters to the types declared in the
1976      function prototype, or apply default promotions.  */
1977
1978   coerced_params
1979     = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl);
1980
1981   /* Check that the arguments to the function are valid.  */
1982
1983   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
1984
1985   result = build3 (CALL_EXPR, TREE_TYPE (fntype),
1986                    function, coerced_params, NULL_TREE);
1987   TREE_SIDE_EFFECTS (result) = 1;
1988
1989   if (require_constant_value)
1990     {
1991       result = fold_initializer (result);
1992
1993       if (TREE_CONSTANT (result)
1994           && (name == NULL_TREE
1995               || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
1996         pedwarn_init ("initializer element is not constant");
1997     }
1998   else
1999     result = fold (result);
2000
2001   if (VOID_TYPE_P (TREE_TYPE (result)))
2002     return result;
2003   return require_complete_type (result);
2004 }
2005 \f
2006 /* Convert the argument expressions in the list VALUES
2007    to the types in the list TYPELIST.  The result is a list of converted
2008    argument expressions.
2009
2010    If TYPELIST is exhausted, or when an element has NULL as its type,
2011    perform the default conversions.
2012
2013    PARMLIST is the chain of parm decls for the function being called.
2014    It may be 0, if that info is not available.
2015    It is used only for generating error messages.
2016
2017    FUNCTION is a tree for the called function.  It is used only for
2018    error messages, where it is formatted with %qE.
2019
2020    This is also where warnings about wrong number of args are generated.
2021
2022    Both VALUES and the returned value are chains of TREE_LIST nodes
2023    with the elements of the list in the TREE_VALUE slots of those nodes.  */
2024
2025 static tree
2026 convert_arguments (tree typelist, tree values, tree function, tree fundecl)
2027 {
2028   tree typetail, valtail;
2029   tree result = NULL;
2030   int parmnum;
2031   tree selector;
2032   tree name = NULL_TREE;
2033
2034   /* Determine the function name for the use of convert_for_assignment
2035      and warn_for_assignment called from there.  */
2036   if (TREE_CODE (function) == ADDR_EXPR
2037       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2038     {
2039       function = TREE_OPERAND (function, 0);
2040       name = DECL_NAME (function);
2041     }
2042
2043   /* Handle an ObjC selector specially for diagnostics.  */
2044   selector = objc_message_selector ();
2045
2046   /* Scan the given expressions and types, producing individual
2047      converted arguments and pushing them on RESULT in reverse order.  */
2048
2049   for (valtail = values, typetail = typelist, parmnum = 0;
2050        valtail;
2051        valtail = TREE_CHAIN (valtail), parmnum++)
2052     {
2053       tree type = typetail ? TREE_VALUE (typetail) : 0;
2054       tree val = TREE_VALUE (valtail);
2055       tree rname = function;
2056       int argnum = parmnum + 1;
2057
2058       if (type == void_type_node)
2059         {
2060           error ("too many arguments to function %qE", function);
2061           break;
2062         }
2063
2064       if (selector && argnum > 2)
2065         {
2066           rname = selector;
2067           argnum -= 2;
2068         }
2069
2070       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
2071       /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
2072          to convert automatically to a pointer.  */
2073       if (TREE_CODE (val) == NON_LVALUE_EXPR)
2074         val = TREE_OPERAND (val, 0);
2075
2076       val = default_function_array_conversion (val);
2077
2078       val = require_complete_type (val);
2079
2080       if (type != 0)
2081         {
2082           /* Formal parm type is specified by a function prototype.  */
2083           tree parmval;
2084
2085           if (!COMPLETE_TYPE_P (type))
2086             {
2087               error ("type of formal parameter %d is incomplete", parmnum + 1);
2088               parmval = val;
2089             }
2090           else
2091             {
2092               /* Optionally warn about conversions that
2093                  differ from the default conversions.  */
2094               if (warn_conversion || warn_traditional)
2095                 {
2096                   unsigned int formal_prec = TYPE_PRECISION (type);
2097
2098                   if (INTEGRAL_TYPE_P (type)
2099                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2100                     warning ("passing argument %d of %qE as integer "
2101                              "rather than floating due to prototype",
2102                              argnum, rname);
2103                   if (INTEGRAL_TYPE_P (type)
2104                       && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2105                     warning ("passing argument %d of %qE as integer "
2106                              "rather than complex due to prototype",
2107                              argnum, rname);
2108                   else if (TREE_CODE (type) == COMPLEX_TYPE
2109                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2110                     warning ("passing argument %d of %qE as complex "
2111                              "rather than floating due to prototype",
2112                              argnum, rname);
2113                   else if (TREE_CODE (type) == REAL_TYPE
2114                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2115                     warning ("passing argument %d of %qE as floating "
2116                              "rather than integer due to prototype",
2117                              argnum, rname);
2118                   else if (TREE_CODE (type) == COMPLEX_TYPE
2119                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2120                     warning ("passing argument %d of %qE as complex "
2121                              "rather than integer due to prototype",
2122                              argnum, rname);
2123                   else if (TREE_CODE (type) == REAL_TYPE
2124                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2125                     warning ("passing argument %d of %qE as floating "
2126                              "rather than complex due to prototype",
2127                              argnum, rname);
2128                   /* ??? At some point, messages should be written about
2129                      conversions between complex types, but that's too messy
2130                      to do now.  */
2131                   else if (TREE_CODE (type) == REAL_TYPE
2132                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2133                     {
2134                       /* Warn if any argument is passed as `float',
2135                          since without a prototype it would be `double'.  */
2136                       if (formal_prec == TYPE_PRECISION (float_type_node))
2137                         warning ("passing argument %d of %qE as %<float%> "
2138                                  "rather than %<double%> due to prototype",
2139                                  argnum, rname);
2140                     }
2141                   /* Detect integer changing in width or signedness.
2142                      These warnings are only activated with
2143                      -Wconversion, not with -Wtraditional.  */
2144                   else if (warn_conversion && INTEGRAL_TYPE_P (type)
2145                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2146                     {
2147                       tree would_have_been = default_conversion (val);
2148                       tree type1 = TREE_TYPE (would_have_been);
2149
2150                       if (TREE_CODE (type) == ENUMERAL_TYPE
2151                           && (TYPE_MAIN_VARIANT (type)
2152                               == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
2153                         /* No warning if function asks for enum
2154                            and the actual arg is that enum type.  */
2155                         ;
2156                       else if (formal_prec != TYPE_PRECISION (type1))
2157                         warning ("passing argument %d of %qE with different "
2158                                  "width due to prototype", argnum, rname);
2159                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2160                         ;
2161                       /* Don't complain if the formal parameter type
2162                          is an enum, because we can't tell now whether
2163                          the value was an enum--even the same enum.  */
2164                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
2165                         ;
2166                       else if (TREE_CODE (val) == INTEGER_CST
2167                                && int_fits_type_p (val, type))
2168                         /* Change in signedness doesn't matter
2169                            if a constant value is unaffected.  */
2170                         ;
2171                       /* Likewise for a constant in a NOP_EXPR.  */
2172                       else if (TREE_CODE (val) == NOP_EXPR
2173                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
2174                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
2175                         ;
2176                       /* If the value is extended from a narrower
2177                          unsigned type, it doesn't matter whether we
2178                          pass it as signed or unsigned; the value
2179                          certainly is the same either way.  */
2180                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
2181                                && TYPE_UNSIGNED (TREE_TYPE (val)))
2182                         ;
2183                       else if (TYPE_UNSIGNED (type))
2184                         warning ("passing argument %d of %qE as unsigned "
2185                                  "due to prototype", argnum, rname);
2186                       else
2187                         warning ("passing argument %d of %qE as signed "
2188                                  "due to prototype", argnum, rname);
2189                     }
2190                 }
2191
2192               parmval = convert_for_assignment (type, val,
2193                                                 (char *) 0, /* arg passing  */
2194                                                 fundecl, name, parmnum + 1);
2195
2196               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
2197                   && INTEGRAL_TYPE_P (type)
2198                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2199                 parmval = default_conversion (parmval);
2200             }
2201           result = tree_cons (NULL_TREE, parmval, result);
2202         }
2203       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2204                && (TYPE_PRECISION (TREE_TYPE (val))
2205                    < TYPE_PRECISION (double_type_node)))
2206         /* Convert `float' to `double'.  */
2207         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2208       else
2209         /* Convert `short' and `char' to full-size `int'.  */
2210         result = tree_cons (NULL_TREE, default_conversion (val), result);
2211
2212       if (typetail)
2213         typetail = TREE_CHAIN (typetail);
2214     }
2215
2216   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
2217     error ("too few arguments to function %qE", function);
2218
2219   return nreverse (result);
2220 }
2221 \f
2222 /* This is the entry point used by the parser
2223    for binary operators in the input.
2224    In addition to constructing the expression,
2225    we check for operands that were written with other binary operators
2226    in a way that is likely to confuse the user.  */
2227
2228 struct c_expr
2229 parser_build_binary_op (enum tree_code code, struct c_expr arg1,
2230                         struct c_expr arg2)
2231 {
2232   struct c_expr result;
2233
2234   enum tree_code code1 = arg1.original_code;
2235   enum tree_code code2 = arg2.original_code;
2236
2237   result.value = build_binary_op (code, arg1.value, arg2.value, 1);
2238   result.original_code = code;
2239
2240   if (TREE_CODE (result.value) == ERROR_MARK)
2241     return result;
2242
2243   /* Check for cases such as x+y<<z which users are likely
2244      to misinterpret.  */
2245   if (warn_parentheses)
2246     {
2247       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
2248         {
2249           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2250               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2251             warning ("suggest parentheses around + or - inside shift");
2252         }
2253
2254       if (code == TRUTH_ORIF_EXPR)
2255         {
2256           if (code1 == TRUTH_ANDIF_EXPR
2257               || code2 == TRUTH_ANDIF_EXPR)
2258             warning ("suggest parentheses around && within ||");
2259         }
2260
2261       if (code == BIT_IOR_EXPR)
2262         {
2263           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2264               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2265               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2266               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2267             warning ("suggest parentheses around arithmetic in operand of |");
2268           /* Check cases like x|y==z */
2269           if (TREE_CODE_CLASS (code1) == tcc_comparison
2270               || TREE_CODE_CLASS (code2) == tcc_comparison)
2271             warning ("suggest parentheses around comparison in operand of |");
2272         }
2273
2274       if (code == BIT_XOR_EXPR)
2275         {
2276           if (code1 == BIT_AND_EXPR
2277               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2278               || code2 == BIT_AND_EXPR
2279               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2280             warning ("suggest parentheses around arithmetic in operand of ^");
2281           /* Check cases like x^y==z */
2282           if (TREE_CODE_CLASS (code1) == tcc_comparison
2283               || TREE_CODE_CLASS (code2) == tcc_comparison)
2284             warning ("suggest parentheses around comparison in operand of ^");
2285         }
2286
2287       if (code == BIT_AND_EXPR)
2288         {
2289           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2290               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2291             warning ("suggest parentheses around + or - in operand of &");
2292           /* Check cases like x&y==z */
2293           if (TREE_CODE_CLASS (code1) == tcc_comparison
2294               || TREE_CODE_CLASS (code2) == tcc_comparison)
2295             warning ("suggest parentheses around comparison in operand of &");
2296         }
2297       /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
2298       if (TREE_CODE_CLASS (code) == tcc_comparison
2299           && (TREE_CODE_CLASS (code1) == tcc_comparison
2300               || TREE_CODE_CLASS (code2) == tcc_comparison))
2301         warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2302
2303     }
2304
2305   unsigned_conversion_warning (result.value, arg1.value);
2306   unsigned_conversion_warning (result.value, arg2.value);
2307   overflow_warning (result.value);
2308
2309   return result;
2310 }
2311 \f
2312 /* Return a tree for the difference of pointers OP0 and OP1.
2313    The resulting tree has type int.  */
2314
2315 static tree
2316 pointer_diff (tree op0, tree op1)
2317 {
2318   tree restype = ptrdiff_type_node;
2319
2320   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2321   tree con0, con1, lit0, lit1;
2322   tree orig_op1 = op1;
2323
2324   if (pedantic || warn_pointer_arith)
2325     {
2326       if (TREE_CODE (target_type) == VOID_TYPE)
2327         pedwarn ("pointer of type %<void *%> used in subtraction");
2328       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2329         pedwarn ("pointer to a function used in subtraction");
2330     }
2331
2332   /* If the conversion to ptrdiff_type does anything like widening or
2333      converting a partial to an integral mode, we get a convert_expression
2334      that is in the way to do any simplifications.
2335      (fold-const.c doesn't know that the extra bits won't be needed.
2336      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2337      different mode in place.)
2338      So first try to find a common term here 'by hand'; we want to cover
2339      at least the cases that occur in legal static initializers.  */
2340   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2341   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2342
2343   if (TREE_CODE (con0) == PLUS_EXPR)
2344     {
2345       lit0 = TREE_OPERAND (con0, 1);
2346       con0 = TREE_OPERAND (con0, 0);
2347     }
2348   else
2349     lit0 = integer_zero_node;
2350
2351   if (TREE_CODE (con1) == PLUS_EXPR)
2352     {
2353       lit1 = TREE_OPERAND (con1, 1);
2354       con1 = TREE_OPERAND (con1, 0);
2355     }
2356   else
2357     lit1 = integer_zero_node;
2358
2359   if (operand_equal_p (con0, con1, 0))
2360     {
2361       op0 = lit0;
2362       op1 = lit1;
2363     }
2364
2365
2366   /* First do the subtraction as integers;
2367      then drop through to build the divide operator.
2368      Do not do default conversions on the minus operator
2369      in case restype is a short type.  */
2370
2371   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2372                          convert (restype, op1), 0);
2373   /* This generates an error if op1 is pointer to incomplete type.  */
2374   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2375     error ("arithmetic on pointer to an incomplete type");
2376
2377   /* This generates an error if op0 is pointer to incomplete type.  */
2378   op1 = c_size_in_bytes (target_type);
2379
2380   /* Divide by the size, in easiest possible way.  */
2381   return fold (build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)));
2382 }
2383 \f
2384 /* Construct and perhaps optimize a tree representation
2385    for a unary operation.  CODE, a tree_code, specifies the operation
2386    and XARG is the operand.
2387    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2388    the default promotions (such as from short to int).
2389    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2390    allows non-lvalues; this is only used to handle conversion of non-lvalue
2391    arrays to pointers in C99.  */
2392
2393 tree
2394 build_unary_op (enum tree_code code, tree xarg, int flag)
2395 {
2396   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2397   tree arg = xarg;
2398   tree argtype = 0;
2399   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2400   tree val;
2401   int noconvert = flag;
2402
2403   if (typecode == ERROR_MARK)
2404     return error_mark_node;
2405   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2406     typecode = INTEGER_TYPE;
2407
2408   switch (code)
2409     {
2410     case CONVERT_EXPR:
2411       /* This is used for unary plus, because a CONVERT_EXPR
2412          is enough to prevent anybody from looking inside for
2413          associativity, but won't generate any code.  */
2414       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2415             || typecode == COMPLEX_TYPE
2416             || typecode == VECTOR_TYPE))
2417         {
2418           error ("wrong type argument to unary plus");
2419           return error_mark_node;
2420         }
2421       else if (!noconvert)
2422         arg = default_conversion (arg);
2423       arg = non_lvalue (arg);
2424       break;
2425
2426     case NEGATE_EXPR:
2427       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2428             || typecode == COMPLEX_TYPE
2429             || typecode == VECTOR_TYPE))
2430         {
2431           error ("wrong type argument to unary minus");
2432           return error_mark_node;
2433         }
2434       else if (!noconvert)
2435         arg = default_conversion (arg);
2436       break;
2437
2438     case BIT_NOT_EXPR:
2439       if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2440         {
2441           if (!noconvert)
2442             arg = default_conversion (arg);
2443         }
2444       else if (typecode == COMPLEX_TYPE)
2445         {
2446           code = CONJ_EXPR;
2447           if (pedantic)
2448             pedwarn ("ISO C does not support %<~%> for complex conjugation");
2449           if (!noconvert)
2450             arg = default_conversion (arg);
2451         }
2452       else
2453         {
2454           error ("wrong type argument to bit-complement");
2455           return error_mark_node;
2456         }
2457       break;
2458
2459     case ABS_EXPR:
2460       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2461         {
2462           error ("wrong type argument to abs");
2463           return error_mark_node;
2464         }
2465       else if (!noconvert)
2466         arg = default_conversion (arg);
2467       break;
2468
2469     case CONJ_EXPR:
2470       /* Conjugating a real value is a no-op, but allow it anyway.  */
2471       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2472             || typecode == COMPLEX_TYPE))
2473         {
2474           error ("wrong type argument to conjugation");
2475           return error_mark_node;
2476         }
2477       else if (!noconvert)
2478         arg = default_conversion (arg);
2479       break;
2480
2481     case TRUTH_NOT_EXPR:
2482       if (typecode != INTEGER_TYPE
2483           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2484           && typecode != COMPLEX_TYPE
2485           /* These will convert to a pointer.  */
2486           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2487         {
2488           error ("wrong type argument to unary exclamation mark");
2489           return error_mark_node;
2490         }
2491       arg = lang_hooks.truthvalue_conversion (arg);
2492       return invert_truthvalue (arg);
2493
2494     case NOP_EXPR:
2495       break;
2496
2497     case REALPART_EXPR:
2498       if (TREE_CODE (arg) == COMPLEX_CST)
2499         return TREE_REALPART (arg);
2500       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2501         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2502       else
2503         return arg;
2504
2505     case IMAGPART_EXPR:
2506       if (TREE_CODE (arg) == COMPLEX_CST)
2507         return TREE_IMAGPART (arg);
2508       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2509         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2510       else
2511         return convert (TREE_TYPE (arg), integer_zero_node);
2512
2513     case PREINCREMENT_EXPR:
2514     case POSTINCREMENT_EXPR:
2515     case PREDECREMENT_EXPR:
2516     case POSTDECREMENT_EXPR:
2517
2518       /* Increment or decrement the real part of the value,
2519          and don't change the imaginary part.  */
2520       if (typecode == COMPLEX_TYPE)
2521         {
2522           tree real, imag;
2523
2524           if (pedantic)
2525             pedwarn ("ISO C does not support %<++%> and %<--%>"
2526                      " on complex types");
2527
2528           arg = stabilize_reference (arg);
2529           real = build_unary_op (REALPART_EXPR, arg, 1);
2530           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2531           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
2532                          build_unary_op (code, real, 1), imag);
2533         }
2534
2535       /* Report invalid types.  */
2536
2537       if (typecode != POINTER_TYPE
2538           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2539         {
2540           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2541             error ("wrong type argument to increment");
2542           else
2543             error ("wrong type argument to decrement");
2544
2545           return error_mark_node;
2546         }
2547
2548       {
2549         tree inc;
2550         tree result_type = TREE_TYPE (arg);
2551
2552         arg = get_unwidened (arg, 0);
2553         argtype = TREE_TYPE (arg);
2554
2555         /* Compute the increment.  */
2556
2557         if (typecode == POINTER_TYPE)
2558           {
2559             /* If pointer target is an undefined struct,
2560                we just cannot know how to do the arithmetic.  */
2561             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2562               {
2563                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2564                   error ("increment of pointer to unknown structure");
2565                 else
2566                   error ("decrement of pointer to unknown structure");
2567               }
2568             else if ((pedantic || warn_pointer_arith)
2569                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2570                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2571               {
2572                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2573                   pedwarn ("wrong type argument to increment");
2574                 else
2575                   pedwarn ("wrong type argument to decrement");
2576               }
2577
2578             inc = c_size_in_bytes (TREE_TYPE (result_type));
2579           }
2580         else
2581           inc = integer_one_node;
2582
2583         inc = convert (argtype, inc);
2584
2585         /* Complain about anything else that is not a true lvalue.  */
2586         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2587                                     || code == POSTINCREMENT_EXPR)
2588                                    ? lv_increment
2589                                    : lv_decrement)))
2590           return error_mark_node;
2591
2592         /* Report a read-only lvalue.  */
2593         if (TREE_READONLY (arg))
2594           readonly_error (arg,
2595                           ((code == PREINCREMENT_EXPR
2596                             || code == POSTINCREMENT_EXPR)
2597                            ? lv_increment : lv_decrement));
2598
2599         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2600           val = boolean_increment (code, arg);
2601         else
2602           val = build2 (code, TREE_TYPE (arg), arg, inc);
2603         TREE_SIDE_EFFECTS (val) = 1;
2604         val = convert (result_type, val);
2605         if (TREE_CODE (val) != code)
2606           TREE_NO_WARNING (val) = 1;
2607         return val;
2608       }
2609
2610     case ADDR_EXPR:
2611       /* Note that this operation never does default_conversion.  */
2612
2613       /* Let &* cancel out to simplify resulting code.  */
2614       if (TREE_CODE (arg) == INDIRECT_REF)
2615         {
2616           /* Don't let this be an lvalue.  */
2617           if (lvalue_p (TREE_OPERAND (arg, 0)))
2618             return non_lvalue (TREE_OPERAND (arg, 0));
2619           return TREE_OPERAND (arg, 0);
2620         }
2621
2622       /* For &x[y], return x+y */
2623       if (TREE_CODE (arg) == ARRAY_REF)
2624         {
2625           if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2626             return error_mark_node;
2627           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2628                                   TREE_OPERAND (arg, 1), 1);
2629         }
2630
2631       /* Anything not already handled and not a true memory reference
2632          or a non-lvalue array is an error.  */
2633       else if (typecode != FUNCTION_TYPE && !flag
2634                && !lvalue_or_else (arg, lv_addressof))
2635         return error_mark_node;
2636
2637       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2638       argtype = TREE_TYPE (arg);
2639
2640       /* If the lvalue is const or volatile, merge that into the type
2641          to which the address will point.  Note that you can't get a
2642          restricted pointer by taking the address of something, so we
2643          only have to deal with `const' and `volatile' here.  */
2644       if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
2645           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2646           argtype = c_build_type_variant (argtype,
2647                                           TREE_READONLY (arg),
2648                                           TREE_THIS_VOLATILE (arg));
2649
2650       if (!c_mark_addressable (arg))
2651         return error_mark_node;
2652
2653       if (TREE_CODE (arg) == COMPONENT_REF
2654           && DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
2655         {
2656           error ("attempt to take address of bit-field structure member %qD",
2657                  TREE_OPERAND (arg, 1));
2658           return error_mark_node;
2659         }
2660
2661       argtype = build_pointer_type (argtype);
2662
2663       /* ??? Cope with user tricks that amount to offsetof.  Delete this
2664          when we have proper support for integer constant expressions.  */
2665       val = get_base_address (arg);
2666       if (val && TREE_CODE (val) == INDIRECT_REF
2667           && integer_zerop (TREE_OPERAND (val, 0)))
2668         return fold_convert (argtype, fold_offsetof (arg));
2669
2670       val = build1 (ADDR_EXPR, argtype, arg);
2671
2672       if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
2673         TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
2674
2675       return val;
2676
2677     default:
2678       break;
2679     }
2680
2681   if (argtype == 0)
2682     argtype = TREE_TYPE (arg);
2683   val = build1 (code, argtype, arg);
2684   return require_constant_value ? fold_initializer (val) : fold (val);
2685 }
2686
2687 /* Return nonzero if REF is an lvalue valid for this language.
2688    Lvalues can be assigned, unless their type has TYPE_READONLY.
2689    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
2690
2691 int
2692 lvalue_p (tree ref)
2693 {
2694   enum tree_code code = TREE_CODE (ref);
2695
2696   switch (code)
2697     {
2698     case REALPART_EXPR:
2699     case IMAGPART_EXPR:
2700     case COMPONENT_REF:
2701       return lvalue_p (TREE_OPERAND (ref, 0));
2702
2703     case COMPOUND_LITERAL_EXPR:
2704     case STRING_CST:
2705       return 1;
2706
2707     case INDIRECT_REF:
2708     case ARRAY_REF:
2709     case VAR_DECL:
2710     case PARM_DECL:
2711     case RESULT_DECL:
2712     case ERROR_MARK:
2713       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2714               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2715
2716     case BIND_EXPR:
2717       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2718
2719     default:
2720       return 0;
2721     }
2722 }
2723
2724 /* Return nonzero if REF is an lvalue valid for this language;
2725    otherwise, print an error message and return zero.  USE says
2726    how the lvalue is being used and so selects the error message.  */
2727
2728 static int
2729 lvalue_or_else (tree ref, enum lvalue_use use)
2730 {
2731   int win = lvalue_p (ref);
2732
2733   if (!win)
2734     {
2735       switch (use)
2736         {
2737         case lv_assign:
2738           error ("invalid lvalue in assignment");
2739           break;
2740         case lv_increment:
2741           error ("invalid lvalue in increment");
2742           break;
2743         case lv_decrement:
2744           error ("invalid lvalue in decrement");
2745           break;
2746         case lv_addressof:
2747           error ("invalid lvalue in unary %<&%>");
2748           break;
2749         case lv_asm:
2750           error ("invalid lvalue in asm statement");
2751           break;
2752         default:
2753           gcc_unreachable ();
2754         }
2755     }
2756
2757   return win;
2758 }
2759
2760 \f
2761 /* Give an error for storing in something that is 'const'.  */
2762
2763 static void
2764 readonly_error (tree arg, enum lvalue_use use)
2765 {
2766   gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement);
2767   /* Using this macro rather than (for example) arrays of messages
2768      ensures that all the format strings are checked at compile
2769      time.  */
2770 #define READONLY_MSG(A, I, D) (use == lv_assign                         \
2771                                ? (A)                                    \
2772                                : (use == lv_increment ? (I) : (D)))
2773   if (TREE_CODE (arg) == COMPONENT_REF)
2774     {
2775       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2776         readonly_error (TREE_OPERAND (arg, 0), use);
2777       else
2778         error (READONLY_MSG (N_("assignment of read-only member %qs"),
2779                              N_("increment of read-only member %qs"),
2780                              N_("decrement of read-only member %qs")),
2781                IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2782     }
2783   else if (TREE_CODE (arg) == VAR_DECL)
2784     error (READONLY_MSG (N_("assignment of read-only variable %qs"),
2785                          N_("increment of read-only variable %qs"),
2786                          N_("decrement of read-only variable %qs")),
2787            IDENTIFIER_POINTER (DECL_NAME (arg)));
2788   else
2789     error (READONLY_MSG (N_("assignment of read-only location"),
2790                          N_("increment of read-only location"),
2791                          N_("decrement of read-only location")));
2792 }
2793 \f
2794 /* Mark EXP saying that we need to be able to take the
2795    address of it; it should not be allocated in a register.
2796    Returns true if successful.  */
2797
2798 bool
2799 c_mark_addressable (tree exp)
2800 {
2801   tree x = exp;
2802
2803   while (1)
2804     switch (TREE_CODE (x))
2805       {
2806       case COMPONENT_REF:
2807         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2808           {
2809             error ("cannot take address of bit-field %qs",
2810                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
2811             return false;
2812           }
2813
2814         /* ... fall through ...  */
2815
2816       case ADDR_EXPR:
2817       case ARRAY_REF:
2818       case REALPART_EXPR:
2819       case IMAGPART_EXPR:
2820         x = TREE_OPERAND (x, 0);
2821         break;
2822
2823       case COMPOUND_LITERAL_EXPR:
2824       case CONSTRUCTOR:
2825         TREE_ADDRESSABLE (x) = 1;
2826         return true;
2827
2828       case VAR_DECL:
2829       case CONST_DECL:
2830       case PARM_DECL:
2831       case RESULT_DECL:
2832         if (C_DECL_REGISTER (x)
2833             && DECL_NONLOCAL (x))
2834           {
2835             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2836               {
2837                 error ("global register variable %qs used in nested function",
2838                        IDENTIFIER_POINTER (DECL_NAME (x)));
2839                 return false;
2840               }
2841             pedwarn ("register variable %qs used in nested function",
2842                      IDENTIFIER_POINTER (DECL_NAME (x)));
2843           }
2844         else if (C_DECL_REGISTER (x))
2845           {
2846             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2847               {
2848                 error ("address of global register variable %qs requested",
2849                        IDENTIFIER_POINTER (DECL_NAME (x)));
2850                 return false;
2851               }
2852
2853             pedwarn ("address of register variable %qs requested",
2854                      IDENTIFIER_POINTER (DECL_NAME (x)));
2855           }
2856
2857         /* drops in */
2858       case FUNCTION_DECL:
2859         TREE_ADDRESSABLE (x) = 1;
2860         /* drops out */
2861       default:
2862         return true;
2863     }
2864 }
2865 \f
2866 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
2867
2868 tree
2869 build_conditional_expr (tree ifexp, tree op1, tree op2)
2870 {
2871   tree type1;
2872   tree type2;
2873   enum tree_code code1;
2874   enum tree_code code2;
2875   tree result_type = NULL;
2876   tree orig_op1 = op1, orig_op2 = op2;
2877
2878   ifexp = lang_hooks.truthvalue_conversion (default_conversion (ifexp));
2879
2880   /* Promote both alternatives.  */
2881
2882   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2883     op1 = default_conversion (op1);
2884   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2885     op2 = default_conversion (op2);
2886
2887   if (TREE_CODE (ifexp) == ERROR_MARK
2888       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2889       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2890     return error_mark_node;
2891
2892   type1 = TREE_TYPE (op1);
2893   code1 = TREE_CODE (type1);
2894   type2 = TREE_TYPE (op2);
2895   code2 = TREE_CODE (type2);
2896
2897   /* C90 does not permit non-lvalue arrays in conditional expressions.
2898      In C99 they will be pointers by now.  */
2899   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2900     {
2901       error ("non-lvalue array in conditional expression");
2902       return error_mark_node;
2903     }
2904
2905   /* Quickly detect the usual case where op1 and op2 have the same type
2906      after promotion.  */
2907   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2908     {
2909       if (type1 == type2)
2910         result_type = type1;
2911       else
2912         result_type = TYPE_MAIN_VARIANT (type1);
2913     }
2914   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2915             || code1 == COMPLEX_TYPE)
2916            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2917                || code2 == COMPLEX_TYPE))
2918     {
2919       result_type = common_type (type1, type2);
2920
2921       /* If -Wsign-compare, warn here if type1 and type2 have
2922          different signedness.  We'll promote the signed to unsigned
2923          and later code won't know it used to be different.
2924          Do this check on the original types, so that explicit casts
2925          will be considered, but default promotions won't.  */
2926       if (warn_sign_compare && !skip_evaluation)
2927         {
2928           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
2929           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
2930
2931           if (unsigned_op1 ^ unsigned_op2)
2932             {
2933               /* Do not warn if the result type is signed, since the
2934                  signed type will only be chosen if it can represent
2935                  all the values of the unsigned type.  */
2936               if (!TYPE_UNSIGNED (result_type))
2937                 /* OK */;
2938               /* Do not warn if the signed quantity is an unsuffixed
2939                  integer literal (or some static constant expression
2940                  involving such literals) and it is non-negative.  */
2941               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
2942                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
2943                 /* OK */;
2944               else
2945                 warning ("signed and unsigned type in conditional expression");
2946             }
2947         }
2948     }
2949   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2950     {
2951       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2952         pedwarn ("ISO C forbids conditional expr with only one void side");
2953       result_type = void_type_node;
2954     }
2955   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2956     {
2957       if (comp_target_types (type1, type2, 1))
2958         result_type = common_pointer_type (type1, type2);
2959       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2960                && TREE_CODE (orig_op1) != NOP_EXPR)
2961         result_type = qualify_type (type2, type1);
2962       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2963                && TREE_CODE (orig_op2) != NOP_EXPR)
2964         result_type = qualify_type (type1, type2);
2965       else if (VOID_TYPE_P (TREE_TYPE (type1)))
2966         {
2967           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2968             pedwarn ("ISO C forbids conditional expr between "
2969                      "%<void *%> and function pointer");
2970           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2971                                                           TREE_TYPE (type2)));
2972         }
2973       else if (VOID_TYPE_P (TREE_TYPE (type2)))
2974         {
2975           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2976             pedwarn ("ISO C forbids conditional expr between "
2977                      "%<void *%> and function pointer");
2978           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2979                                                           TREE_TYPE (type1)));
2980         }
2981       else
2982         {
2983           pedwarn ("pointer type mismatch in conditional expression");
2984           result_type = build_pointer_type (void_type_node);
2985         }
2986     }
2987   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2988     {
2989       if (!integer_zerop (op2))
2990         pedwarn ("pointer/integer type mismatch in conditional expression");
2991       else
2992         {
2993           op2 = null_pointer_node;
2994         }
2995       result_type = type1;
2996     }
2997   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2998     {
2999       if (!integer_zerop (op1))
3000         pedwarn ("pointer/integer type mismatch in conditional expression");
3001       else
3002         {
3003           op1 = null_pointer_node;
3004         }
3005       result_type = type2;
3006     }
3007
3008   if (!result_type)
3009     {
3010       if (flag_cond_mismatch)
3011         result_type = void_type_node;
3012       else
3013         {
3014           error ("type mismatch in conditional expression");
3015           return error_mark_node;
3016         }
3017     }
3018
3019   /* Merge const and volatile flags of the incoming types.  */
3020   result_type
3021     = build_type_variant (result_type,
3022                           TREE_READONLY (op1) || TREE_READONLY (op2),
3023                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3024
3025   if (result_type != TREE_TYPE (op1))
3026     op1 = convert_and_check (result_type, op1);
3027   if (result_type != TREE_TYPE (op2))
3028     op2 = convert_and_check (result_type, op2);
3029
3030   if (TREE_CODE (ifexp) == INTEGER_CST)
3031     return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3032
3033   return fold (build3 (COND_EXPR, result_type, ifexp, op1, op2));
3034 }
3035 \f
3036 /* Return a compound expression that performs two expressions and
3037    returns the value of the second of them.  */
3038
3039 tree
3040 build_compound_expr (tree expr1, tree expr2)
3041 {
3042   /* Convert arrays and functions to pointers.  */
3043   expr2 = default_function_array_conversion (expr2);
3044
3045   /* Don't let (0, 0) be null pointer constant.  */
3046   if (integer_zerop (expr2))
3047     expr2 = non_lvalue (expr2);
3048
3049   if (!TREE_SIDE_EFFECTS (expr1))
3050     {
3051       /* The left-hand operand of a comma expression is like an expression
3052          statement: with -Wextra or -Wunused, we should warn if it doesn't have
3053          any side-effects, unless it was explicitly cast to (void).  */
3054       if (warn_unused_value
3055            && !(TREE_CODE (expr1) == CONVERT_EXPR
3056                 && VOID_TYPE_P (TREE_TYPE (expr1))))
3057         warning ("left-hand operand of comma expression has no effect");
3058     }
3059
3060   /* With -Wunused, we should also warn if the left-hand operand does have
3061      side-effects, but computes a value which is not used.  For example, in
3062      `foo() + bar(), baz()' the result of the `+' operator is not used,
3063      so we should issue a warning.  */
3064   else if (warn_unused_value)
3065     warn_if_unused_value (expr1, input_location);
3066
3067   return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
3068 }
3069
3070 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3071
3072 tree
3073 build_c_cast (tree type, tree expr)
3074 {
3075   tree value = expr;
3076
3077   if (type == error_mark_node || expr == error_mark_node)
3078     return error_mark_node;
3079
3080   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3081      only in <protocol> qualifications.  But when constructing cast expressions,
3082      the protocols do matter and must be kept around.  */
3083   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
3084     return build1 (NOP_EXPR, type, expr);
3085
3086   type = TYPE_MAIN_VARIANT (type);
3087
3088   if (TREE_CODE (type) == ARRAY_TYPE)
3089     {
3090       error ("cast specifies array type");
3091       return error_mark_node;
3092     }
3093
3094   if (TREE_CODE (type) == FUNCTION_TYPE)
3095     {
3096       error ("cast specifies function type");
3097       return error_mark_node;
3098     }
3099
3100   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3101     {
3102       if (pedantic)
3103         {
3104           if (TREE_CODE (type) == RECORD_TYPE
3105               || TREE_CODE (type) == UNION_TYPE)
3106             pedwarn ("ISO C forbids casting nonscalar to the same type");
3107         }
3108     }
3109   else if (TREE_CODE (type) == UNION_TYPE)
3110     {
3111       tree field;
3112       value = default_function_array_conversion (value);
3113
3114       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3115         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3116                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3117           break;
3118
3119       if (field)
3120         {
3121           tree t;
3122
3123           if (pedantic)
3124             pedwarn ("ISO C forbids casts to union type");
3125           t = digest_init (type,
3126                            build_constructor (type,
3127                                               build_tree_list (field, value)),
3128                            true, 0);
3129           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3130           TREE_INVARIANT (t) = TREE_INVARIANT (value);
3131           return t;
3132         }
3133       error ("cast to union type from type not present in union");
3134       return error_mark_node;
3135     }
3136   else
3137     {
3138       tree otype, ovalue;
3139
3140       /* If casting to void, avoid the error that would come
3141          from default_conversion in the case of a non-lvalue array.  */
3142       if (type == void_type_node)
3143         return build1 (CONVERT_EXPR, type, value);
3144
3145       /* Convert functions and arrays to pointers,
3146          but don't convert any other types.  */
3147       value = default_function_array_conversion (value);
3148       otype = TREE_TYPE (value);
3149
3150       /* Optionally warn about potentially worrisome casts.  */
3151
3152       if (warn_cast_qual
3153           && TREE_CODE (type) == POINTER_TYPE
3154           && TREE_CODE (otype) == POINTER_TYPE)
3155         {
3156           tree in_type = type;
3157           tree in_otype = otype;
3158           int added = 0;
3159           int discarded = 0;
3160
3161           /* Check that the qualifiers on IN_TYPE are a superset of
3162              the qualifiers of IN_OTYPE.  The outermost level of
3163              POINTER_TYPE nodes is uninteresting and we stop as soon
3164              as we hit a non-POINTER_TYPE node on either type.  */
3165           do
3166             {
3167               in_otype = TREE_TYPE (in_otype);
3168               in_type = TREE_TYPE (in_type);
3169
3170               /* GNU C allows cv-qualified function types.  'const'
3171                  means the function is very pure, 'volatile' means it
3172                  can't return.  We need to warn when such qualifiers
3173                  are added, not when they're taken away.  */
3174               if (TREE_CODE (in_otype) == FUNCTION_TYPE
3175                   && TREE_CODE (in_type) == FUNCTION_TYPE)
3176                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3177               else
3178                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3179             }
3180           while (TREE_CODE (in_type) == POINTER_TYPE
3181                  && TREE_CODE (in_otype) == POINTER_TYPE);
3182
3183           if (added)
3184             warning ("cast adds new qualifiers to function type");
3185
3186           if (discarded)
3187             /* There are qualifiers present in IN_OTYPE that are not
3188                present in IN_TYPE.  */
3189             warning ("cast discards qualifiers from pointer target type");
3190         }
3191
3192       /* Warn about possible alignment problems.  */
3193       if (STRICT_ALIGNMENT && warn_cast_align
3194           && TREE_CODE (type) == POINTER_TYPE
3195           && TREE_CODE (otype) == POINTER_TYPE
3196           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3197           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3198           /* Don't warn about opaque types, where the actual alignment
3199              restriction is unknown.  */
3200           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3201                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3202                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3203           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3204         warning ("cast increases required alignment of target type");
3205
3206       if (TREE_CODE (type) == INTEGER_TYPE
3207           && TREE_CODE (otype) == POINTER_TYPE
3208           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3209           && !TREE_CONSTANT (value))
3210         warning ("cast from pointer to integer of different size");
3211
3212       if (warn_bad_function_cast
3213           && TREE_CODE (value) == CALL_EXPR
3214           && TREE_CODE (type) != TREE_CODE (otype))
3215         warning ("cast from function call of type %qT to non-matching "
3216                  "type %qT", otype, type);
3217
3218       if (TREE_CODE (type) == POINTER_TYPE
3219           && TREE_CODE (otype) == INTEGER_TYPE
3220           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3221           /* Don't warn about converting any constant.  */
3222           && !TREE_CONSTANT (value))
3223         warning ("cast to pointer from integer of different size");
3224
3225       if (TREE_CODE (type) == POINTER_TYPE
3226           && TREE_CODE (otype) == POINTER_TYPE
3227           && TREE_CODE (expr) == ADDR_EXPR
3228           && DECL_P (TREE_OPERAND (expr, 0))
3229           && flag_strict_aliasing && warn_strict_aliasing
3230           && !VOID_TYPE_P (TREE_TYPE (type)))
3231         {
3232           /* Casting the address of a decl to non void pointer. Warn
3233              if the cast breaks type based aliasing.  */
3234           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3235             warning ("type-punning to incomplete type might break strict-aliasing rules");
3236           else
3237             {
3238               HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
3239               HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
3240
3241               if (!alias_sets_conflict_p (set1, set2))
3242                 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3243               else if (warn_strict_aliasing > 1
3244                        && !alias_sets_might_conflict_p (set1, set2))
3245                 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3246             }
3247         }
3248
3249       /* If pedantic, warn for conversions between function and object
3250          pointer types, except for converting a null pointer constant
3251          to function pointer type.  */
3252       if (pedantic
3253           && TREE_CODE (type) == POINTER_TYPE
3254           && TREE_CODE (otype) == POINTER_TYPE
3255           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3256           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3257         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3258
3259       if (pedantic
3260           && TREE_CODE (type) == POINTER_TYPE
3261           && TREE_CODE (otype) == POINTER_TYPE
3262           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3263           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3264           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3265                && TREE_CODE (expr) != NOP_EXPR))
3266         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3267
3268       ovalue = value;
3269       /* Replace a nonvolatile const static variable with its value.  */
3270       if (optimize && TREE_CODE (value) == VAR_DECL)
3271         value = decl_constant_value (value);
3272       value = convert (type, value);
3273
3274       /* Ignore any integer overflow caused by the cast.  */
3275       if (TREE_CODE (value) == INTEGER_CST)
3276         {
3277           if (EXPR_P (ovalue))
3278             /* If OVALUE had overflow set, then so will VALUE, so it
3279                is safe to overwrite.  */
3280             TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3281           else
3282             TREE_OVERFLOW (value) = 0;
3283           
3284           if (CONSTANT_CLASS_P (ovalue))
3285             /* Similarly, constant_overflow cannot have become
3286                cleared.  */
3287             TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3288         }
3289     }
3290
3291   /* Don't let (void *) (FOO *) 0 be a null pointer constant.  */
3292   if (TREE_CODE (value) == INTEGER_CST
3293       && TREE_CODE (expr) == INTEGER_CST
3294       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3295     value = non_lvalue (value);
3296
3297   /* Don't let a cast be an lvalue.  */
3298   if (value == expr)
3299     value = non_lvalue (value);
3300
3301   return value;
3302 }
3303
3304 /* Interpret a cast of expression EXPR to type TYPE.  */
3305 tree
3306 c_cast_expr (struct c_type_name *type_name, tree expr)
3307 {
3308   tree type;
3309   int saved_wsp = warn_strict_prototypes;
3310
3311   /* This avoids warnings about unprototyped casts on
3312      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3313   if (TREE_CODE (expr) == INTEGER_CST)
3314     warn_strict_prototypes = 0;
3315   type = groktypename (type_name);
3316   warn_strict_prototypes = saved_wsp;
3317
3318   return build_c_cast (type, expr);
3319 }
3320
3321 \f
3322 /* Build an assignment expression of lvalue LHS from value RHS.
3323    MODIFYCODE is the code for a binary operator that we use
3324    to combine the old value of LHS with RHS to get the new value.
3325    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3326
3327 tree
3328 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3329 {
3330   tree result;
3331   tree newrhs;
3332   tree lhstype = TREE_TYPE (lhs);
3333   tree olhstype = lhstype;
3334
3335   /* Types that aren't fully specified cannot be used in assignments.  */
3336   lhs = require_complete_type (lhs);
3337
3338   /* Avoid duplicate error messages from operands that had errors.  */
3339   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3340     return error_mark_node;
3341
3342   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3343   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3344      whose value is 0 to count as a null pointer constant.  */
3345   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3346     rhs = TREE_OPERAND (rhs, 0);
3347
3348   newrhs = rhs;
3349
3350   /* If a binary op has been requested, combine the old LHS value with the RHS
3351      producing the value we should actually store into the LHS.  */
3352
3353   if (modifycode != NOP_EXPR)
3354     {
3355       lhs = stabilize_reference (lhs);
3356       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3357     }
3358
3359   if (!lvalue_or_else (lhs, lv_assign))
3360     return error_mark_node;
3361
3362   /* Give an error for storing in something that is 'const'.  */
3363
3364   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3365       || ((TREE_CODE (lhstype) == RECORD_TYPE
3366            || TREE_CODE (lhstype) == UNION_TYPE)
3367           && C_TYPE_FIELDS_READONLY (lhstype)))
3368     readonly_error (lhs, lv_assign);
3369
3370   /* If storing into a structure or union member,
3371      it has probably been given type `int'.
3372      Compute the type that would go with
3373      the actual amount of storage the member occupies.  */
3374
3375   if (TREE_CODE (lhs) == COMPONENT_REF
3376       && (TREE_CODE (lhstype) == INTEGER_TYPE
3377           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3378           || TREE_CODE (lhstype) == REAL_TYPE
3379           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3380     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3381
3382   /* If storing in a field that is in actuality a short or narrower than one,
3383      we must store in the field in its actual type.  */
3384
3385   if (lhstype != TREE_TYPE (lhs))
3386     {
3387       lhs = copy_node (lhs);
3388       TREE_TYPE (lhs) = lhstype;
3389     }
3390
3391   /* Convert new value to destination type.  */
3392
3393   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3394                                    NULL_TREE, NULL_TREE, 0);
3395   if (TREE_CODE (newrhs) == ERROR_MARK)
3396     return error_mark_node;
3397
3398   /* Scan operands.  */
3399
3400   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3401   TREE_SIDE_EFFECTS (result) = 1;
3402
3403   /* If we got the LHS in a different type for storing in,
3404      convert the result back to the nominal type of LHS
3405      so that the value we return always has the same type
3406      as the LHS argument.  */
3407
3408   if (olhstype == TREE_TYPE (result))
3409     return result;
3410   return convert_for_assignment (olhstype, result, _("assignment"),
3411                                  NULL_TREE, NULL_TREE, 0);
3412 }
3413 \f
3414 /* Convert value RHS to type TYPE as preparation for an assignment
3415    to an lvalue of type TYPE.
3416    The real work of conversion is done by `convert'.
3417    The purpose of this function is to generate error messages
3418    for assignments that are not allowed in C.
3419    ERRTYPE is a string to use in error messages:
3420    "assignment", "return", etc.  If it is null, this is parameter passing
3421    for a function call (and different error messages are output).
3422
3423    FUNNAME is the name of the function being called,
3424    as an IDENTIFIER_NODE, or null.
3425    PARMNUM is the number of the argument, for printing in error messages.  */
3426
3427 static tree
3428 convert_for_assignment (tree type, tree rhs, const char *errtype,
3429                         tree fundecl, tree funname, int parmnum)
3430 {
3431   enum tree_code codel = TREE_CODE (type);
3432   tree rhstype;
3433   enum tree_code coder;
3434
3435   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3436   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3437      whose value is 0 to count as a null pointer constant.  */
3438   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3439     rhs = TREE_OPERAND (rhs, 0);
3440
3441   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3442       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3443     rhs = default_conversion (rhs);
3444   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3445     rhs = decl_constant_value_for_broken_optimization (rhs);
3446
3447   rhstype = TREE_TYPE (rhs);
3448   coder = TREE_CODE (rhstype);
3449
3450   if (coder == ERROR_MARK)
3451     return error_mark_node;
3452
3453   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3454     {
3455       overflow_warning (rhs);
3456       /* Check for Objective-C protocols.  This will automatically
3457          issue a warning if there are protocol violations.  No need to
3458          use the return value.  */
3459       if (c_dialect_objc ())
3460         objc_comptypes (type, rhstype, 0);
3461       return rhs;
3462     }
3463
3464   if (coder == VOID_TYPE)
3465     {
3466       error ("void value not ignored as it ought to be");
3467       return error_mark_node;
3468     }
3469   /* A type converts to a reference to it.
3470      This code doesn't fully support references, it's just for the
3471      special case of va_start and va_copy.  */
3472   if (codel == REFERENCE_TYPE
3473       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3474     {
3475       if (!lvalue_p (rhs))
3476         {
3477           error ("cannot pass rvalue to reference parameter");
3478           return error_mark_node;
3479         }
3480       if (!c_mark_addressable (rhs))
3481         return error_mark_node;
3482       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3483
3484       /* We already know that these two types are compatible, but they
3485          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3486          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3487          likely to be va_list, a typedef to __builtin_va_list, which
3488          is different enough that it will cause problems later.  */
3489       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3490         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3491
3492       rhs = build1 (NOP_EXPR, type, rhs);
3493       return rhs;
3494     }
3495   /* Some types can interconvert without explicit casts.  */
3496   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3497            && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3498     return convert (type, rhs);
3499   /* Arithmetic types all interconvert, and enum is treated like int.  */
3500   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3501             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3502             || codel == BOOLEAN_TYPE)
3503            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3504                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3505                || coder == BOOLEAN_TYPE))
3506     return convert_and_check (type, rhs);
3507
3508   /* Conversion to a transparent union from its member types.
3509      This applies only to function arguments.  */
3510   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && !errtype)
3511     {
3512       tree memb_types;
3513       tree marginal_memb_type = 0;
3514
3515       for (memb_types = TYPE_FIELDS (type); memb_types;
3516            memb_types = TREE_CHAIN (memb_types))
3517         {
3518           tree memb_type = TREE_TYPE (memb_types);
3519
3520           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3521                          TYPE_MAIN_VARIANT (rhstype)))
3522             break;
3523
3524           if (TREE_CODE (memb_type) != POINTER_TYPE)
3525             continue;
3526
3527           if (coder == POINTER_TYPE)
3528             {
3529               tree ttl = TREE_TYPE (memb_type);
3530               tree ttr = TREE_TYPE (rhstype);
3531
3532               /* Any non-function converts to a [const][volatile] void *
3533                  and vice versa; otherwise, targets must be the same.
3534                  Meanwhile, the lhs target must have all the qualifiers of
3535                  the rhs.  */
3536               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3537                   || comp_target_types (memb_type, rhstype, 0))
3538                 {
3539                   /* If this type won't generate any warnings, use it.  */
3540                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3541                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3542                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3543                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3544                              == TYPE_QUALS (ttr))
3545                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3546                              == TYPE_QUALS (ttl))))
3547                     break;
3548
3549                   /* Keep looking for a better type, but remember this one.  */
3550                   if (!marginal_memb_type)
3551                     marginal_memb_type = memb_type;
3552                 }
3553             }
3554
3555           /* Can convert integer zero to any pointer type.  */
3556           if (integer_zerop (rhs)
3557               || (TREE_CODE (rhs) == NOP_EXPR
3558                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3559             {
3560               rhs = null_pointer_node;
3561               break;
3562             }
3563         }
3564
3565       if (memb_types || marginal_memb_type)
3566         {
3567           if (!memb_types)
3568             {
3569               /* We have only a marginally acceptable member type;
3570                  it needs a warning.  */
3571               tree ttl = TREE_TYPE (marginal_memb_type);
3572               tree ttr = TREE_TYPE (rhstype);
3573
3574               /* Const and volatile mean something different for function
3575                  types, so the usual warnings are not appropriate.  */
3576               if (TREE_CODE (ttr) == FUNCTION_TYPE
3577                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3578                 {
3579                   /* Because const and volatile on functions are
3580                      restrictions that say the function will not do
3581                      certain things, it is okay to use a const or volatile
3582                      function where an ordinary one is wanted, but not
3583                      vice-versa.  */
3584                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3585                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
3586                                          errtype, funname, parmnum);
3587                 }
3588               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3589                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3590                                      errtype, funname,
3591                                      parmnum);
3592             }
3593
3594           if (pedantic && !DECL_IN_SYSTEM_HEADER (fundecl))
3595             pedwarn ("ISO C prohibits argument conversion to union type");
3596
3597           return build1 (NOP_EXPR, type, rhs);
3598         }
3599     }
3600
3601   /* Conversions among pointers */
3602   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3603            && (coder == codel))
3604     {
3605       tree ttl = TREE_TYPE (type);
3606       tree ttr = TREE_TYPE (rhstype);
3607       bool is_opaque_pointer;
3608       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3609
3610       /* Opaque pointers are treated like void pointers.  */
3611       is_opaque_pointer = (targetm.vector_opaque_p (type)
3612                            || targetm.vector_opaque_p (rhstype))
3613         && TREE_CODE (ttl) == VECTOR_TYPE
3614         && TREE_CODE (ttr) == VECTOR_TYPE;
3615
3616       /* Any non-function converts to a [const][volatile] void *
3617          and vice versa; otherwise, targets must be the same.
3618          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3619       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3620           || (target_cmp = comp_target_types (type, rhstype, 0))
3621           || is_opaque_pointer
3622           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3623               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3624         {
3625           if (pedantic
3626               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3627                   ||
3628                   (VOID_TYPE_P (ttr)
3629                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3630                       which are not ANSI null ptr constants.  */
3631                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3632                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3633             warn_for_assignment ("ISO C forbids %s between function "
3634                                  "pointer and %<void *%>",
3635                                  errtype, funname, parmnum);
3636           /* Const and volatile mean something different for function types,
3637              so the usual warnings are not appropriate.  */
3638           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3639                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3640             {
3641               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3642                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3643                                      errtype, funname, parmnum);
3644               /* If this is not a case of ignoring a mismatch in signedness,
3645                  no warning.  */
3646               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3647                        || target_cmp)
3648                 ;
3649               /* If there is a mismatch, do warn.  */
3650               else
3651                 warn_for_assignment ("pointer targets in %s differ in signedness",
3652                                      errtype, funname, parmnum);
3653             }
3654           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3655                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3656             {
3657               /* Because const and volatile on functions are restrictions
3658                  that say the function will not do certain things,
3659                  it is okay to use a const or volatile function
3660                  where an ordinary one is wanted, but not vice-versa.  */
3661               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3662                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3663                                      errtype, funname, parmnum);
3664             }
3665         }
3666       else
3667         warn_for_assignment ("%s from incompatible pointer type",
3668                              errtype, funname, parmnum);
3669       return convert (type, rhs);
3670     }
3671   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3672     {
3673       error ("invalid use of non-lvalue array");
3674       return error_mark_node;
3675     }
3676   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3677     {
3678       /* An explicit constant 0 can convert to a pointer,
3679          or one that results from arithmetic, even including
3680          a cast to integer type.  */
3681       if (!(TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3682           &&
3683           !(TREE_CODE (rhs) == NOP_EXPR
3684             && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3685             && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3686             && integer_zerop (TREE_OPERAND (rhs, 0))))
3687           warn_for_assignment ("%s makes pointer from integer without a cast",
3688                                errtype, funname, parmnum);
3689
3690       return convert (type, rhs);
3691     }
3692   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3693     {
3694       warn_for_assignment ("%s makes integer from pointer without a cast",
3695                            errtype, funname, parmnum);
3696       return convert (type, rhs);
3697     }
3698   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3699     return convert (type, rhs);
3700
3701   if (!errtype)
3702     {
3703       if (funname)
3704         {
3705           tree selector = objc_message_selector ();
3706
3707           if (selector && parmnum > 2)
3708             error ("incompatible type for argument %d of %qs",
3709                    parmnum - 2, IDENTIFIER_POINTER (selector));
3710           else
3711             error ("incompatible type for argument %d of %qs",
3712                    parmnum, IDENTIFIER_POINTER (funname));
3713         }
3714       else
3715         error ("incompatible type for argument %d of indirect function call",
3716                parmnum);
3717     }
3718   else
3719     error ("incompatible types in %s", errtype);
3720
3721   return error_mark_node;
3722 }
3723
3724 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3725    is used for error and waring reporting and indicates which argument
3726    is being processed.  */
3727
3728 tree
3729 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3730 {
3731   tree ret, type;
3732
3733   /* If FN was prototyped, the value has been converted already
3734      in convert_arguments.  */
3735   if (!value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3736     return value;
3737
3738   type = TREE_TYPE (parm);
3739   ret = convert_for_assignment (type, value,
3740                                 (char *) 0 /* arg passing  */, fn,
3741                                 DECL_NAME (fn), argnum);
3742   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3743       && INTEGRAL_TYPE_P (type)
3744       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3745     ret = default_conversion (ret);
3746   return ret;
3747 }
3748
3749 /* Print a warning using MSGID.
3750    It gets OPNAME as its one parameter.
3751    If OPNAME is null, it is replaced by "passing arg ARGNUM of 'FUNCTION'".
3752    FUNCTION and ARGNUM are handled specially if we are building an
3753    Objective-C selector.  */
3754
3755 static void
3756 warn_for_assignment (const char *msgid, const char *opname, tree function,
3757                      int argnum)
3758 {
3759   if (opname == 0)
3760     {
3761       tree selector = objc_message_selector ();
3762       char * new_opname;
3763
3764       if (selector && argnum > 2)
3765         {
3766           function = selector;
3767           argnum -= 2;
3768         }
3769       gcc_assert (argnum > 0);
3770       if (function)
3771         {
3772           /* Function name is known; supply it.  */
3773           const char *const argstring = _("passing arg %d of '%s'");
3774           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
3775                                + strlen (argstring) + 1 + 25 /*%d*/ + 1);
3776           sprintf (new_opname, argstring, argnum,
3777                    IDENTIFIER_POINTER (function));
3778         }
3779       else
3780         {
3781           /* Function name unknown (call through ptr); just give arg number.  */
3782           const char *const argnofun = _("passing arg %d of pointer to function");
3783           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
3784           sprintf (new_opname, argnofun, argnum);
3785         }
3786       opname = new_opname;
3787     }
3788   pedwarn (msgid, opname);
3789 }
3790 \f
3791 /* If VALUE is a compound expr all of whose expressions are constant, then
3792    return its value.  Otherwise, return error_mark_node.
3793
3794    This is for handling COMPOUND_EXPRs as initializer elements
3795    which is allowed with a warning when -pedantic is specified.  */
3796
3797 static tree
3798 valid_compound_expr_initializer (tree value, tree endtype)
3799 {
3800   if (TREE_CODE (value) == COMPOUND_EXPR)
3801     {
3802       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3803           == error_mark_node)
3804         return error_mark_node;
3805       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3806                                               endtype);
3807     }
3808   else if (!initializer_constant_valid_p (value, endtype))
3809     return error_mark_node;
3810   else
3811     return value;
3812 }
3813 \f
3814 /* Perform appropriate conversions on the initial value of a variable,
3815    store it in the declaration DECL,
3816    and print any error messages that are appropriate.
3817    If the init is invalid, store an ERROR_MARK.  */
3818
3819 void
3820 store_init_value (tree decl, tree init)
3821 {
3822   tree value, type;
3823
3824   /* If variable's type was invalidly declared, just ignore it.  */
3825
3826   type = TREE_TYPE (decl);
3827   if (TREE_CODE (type) == ERROR_MARK)
3828     return;
3829
3830   /* Digest the specified initializer into an expression.  */
3831
3832   value = digest_init (type, init, true, TREE_STATIC (decl));
3833
3834   /* Store the expression if valid; else report error.  */
3835
3836   if (warn_traditional && !in_system_header
3837       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
3838     warning ("traditional C rejects automatic aggregate initialization");
3839
3840   DECL_INITIAL (decl) = value;
3841
3842   /* ANSI wants warnings about out-of-range constant initializers.  */
3843   STRIP_TYPE_NOPS (value);
3844   constant_expression_warning (value);
3845
3846   /* Check if we need to set array size from compound literal size.  */
3847   if (TREE_CODE (type) == ARRAY_TYPE
3848       && TYPE_DOMAIN (type) == 0
3849       && value != error_mark_node)
3850     {
3851       tree inside_init = init;
3852
3853       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3854         inside_init = TREE_OPERAND (init, 0);
3855       inside_init = fold (inside_init);
3856
3857       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3858         {
3859           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3860
3861           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3862             {
3863               /* For int foo[] = (int [3]){1}; we need to set array size
3864                  now since later on array initializer will be just the
3865                  brace enclosed list of the compound literal.  */
3866               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3867               layout_type (type);
3868               layout_decl (decl, 0);
3869             }
3870         }
3871     }
3872 }
3873 \f
3874 /* Methods for storing and printing names for error messages.  */
3875
3876 /* Implement a spelling stack that allows components of a name to be pushed
3877    and popped.  Each element on the stack is this structure.  */
3878
3879 struct spelling
3880 {
3881   int kind;
3882   union
3883     {
3884       int i;
3885       const char *s;
3886     } u;
3887 };
3888
3889 #define SPELLING_STRING 1
3890 #define SPELLING_MEMBER 2
3891 #define SPELLING_BOUNDS 3
3892
3893 static struct spelling *spelling;       /* Next stack element (unused).  */
3894 static struct spelling *spelling_base;  /* Spelling stack base.  */
3895 static int spelling_size;               /* Size of the spelling stack.  */
3896
3897 /* Macros to save and restore the spelling stack around push_... functions.
3898    Alternative to SAVE_SPELLING_STACK.  */
3899
3900 #define SPELLING_DEPTH() (spelling - spelling_base)
3901 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3902
3903 /* Push an element on the spelling stack with type KIND and assign VALUE
3904    to MEMBER.  */
3905
3906 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3907 {                                                                       \
3908   int depth = SPELLING_DEPTH ();                                        \
3909                                                                         \
3910   if (depth >= spelling_size)                                           \
3911     {                                                                   \
3912       spelling_size += 10;                                              \
3913       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
3914                                   spelling_size);                       \
3915       RESTORE_SPELLING_DEPTH (depth);                                   \
3916     }                                                                   \
3917                                                                         \
3918   spelling->kind = (KIND);                                              \
3919   spelling->MEMBER = (VALUE);                                           \
3920   spelling++;                                                           \
3921 }
3922
3923 /* Push STRING on the stack.  Printed literally.  */
3924
3925 static void
3926 push_string (const char *string)
3927 {
3928   PUSH_SPELLING (SPELLING_STRING, string, u.s);
3929 }
3930
3931 /* Push a member name on the stack.  Printed as '.' STRING.  */
3932
3933 static void
3934 push_member_name (tree decl)
3935 {
3936   const char *const string
3937     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3938   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3939 }
3940
3941 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
3942
3943 static void
3944 push_array_bounds (int bounds)
3945 {
3946   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3947 }
3948
3949 /* Compute the maximum size in bytes of the printed spelling.  */
3950
3951 static int
3952 spelling_length (void)
3953 {
3954   int size = 0;
3955   struct spelling *p;
3956
3957   for (p = spelling_base; p < spelling; p++)
3958     {
3959       if (p->kind == SPELLING_BOUNDS)
3960         size += 25;
3961       else
3962         size += strlen (p->u.s) + 1;
3963     }
3964
3965   return size;
3966 }
3967
3968 /* Print the spelling to BUFFER and return it.  */
3969
3970 static char *
3971 print_spelling (char *buffer)
3972 {
3973   char *d = buffer;
3974   struct spelling *p;
3975
3976   for (p = spelling_base; p < spelling; p++)
3977     if (p->kind == SPELLING_BOUNDS)
3978       {
3979         sprintf (d, "[%d]", p->u.i);
3980         d += strlen (d);
3981       }
3982     else
3983       {
3984         const char *s;
3985         if (p->kind == SPELLING_MEMBER)
3986           *d++ = '.';
3987         for (s = p->u.s; (*d = *s++); d++)
3988           ;
3989       }
3990   *d++ = '\0';
3991   return buffer;
3992 }
3993
3994 /* Issue an error message for a bad initializer component.
3995    MSGID identifies the message.
3996    The component name is taken from the spelling stack.  */
3997
3998 void
3999 error_init (const char *msgid)
4000 {
4001   char *ofwhat;
4002
4003   error ("%s", _(msgid));
4004   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4005   if (*ofwhat)
4006     error ("(near initialization for %qs)", ofwhat);
4007 }
4008
4009 /* Issue a pedantic warning for a bad initializer component.
4010    MSGID identifies the message.
4011    The component name is taken from the spelling stack.  */
4012
4013 void