OSDN Git Service

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