OSDN Git Service

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