OSDN Git Service

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