OSDN Git Service

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