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