OSDN Git Service

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