OSDN Git Service

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