OSDN Git Service

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