OSDN Git Service

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