OSDN Git Service

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