OSDN Git Service

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