OSDN Git Service

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