OSDN Git Service

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