OSDN Git Service

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