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 "c-tree.h"
  39 #include "tm_p.h"
  40 #include "flags.h"
  41 #include "output.h"
  42 #include "expr.h"
  43 #include "toplev.h"
  44 #include "intl.h"
  45 #include "ggc.h"
  46 #include "target.h"
  47
  48 /* Nonzero if we've already printed a "missing braces around initializer"
  49    message within this initializer.  */
  50 static int missing_braces_mentioned;
  51
  52 static tree qualify_type (tree, tree);
  53 static int same_translation_unit_p (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 (TREE_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 longs to ints even when same size.  */
 278
 279       if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 280           || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 281         return build_type_attribute_variant (long_unsigned_type_node,
 282                                              attributes);
 283
 284       if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 285           || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 286         {
 287           /* But preserve unsignedness from the other type,
 288              since long cannot hold all the values of an unsigned int.  */
 289           if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
 290              t1 = long_unsigned_type_node;
 291           else
 292              t1 = long_integer_type_node;
 293           return build_type_attribute_variant (t1, attributes);
 294         }
 295
 296       /* Likewise, prefer long double to double even if same size.  */
 297       if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
 298           || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
 299         return build_type_attribute_variant (long_double_type_node,
 300                                              attributes);
 301
 302       /* Otherwise prefer the unsigned one.  */
 303
 304       if (TREE_UNSIGNED (t1))
 305         return build_type_attribute_variant (t1, attributes);
 306       else
 307         return build_type_attribute_variant (t2, attributes);
 308
 309     case POINTER_TYPE:
 310       /* For two pointers, do this recursively on the target type,
 311          and combine the qualifiers of the two types' targets.  */
 312       /* This code was turned off; I don't know why.
 313          But ANSI C specifies doing this with the qualifiers.
 314          So I turned it on again.  */
 315       {
 316         tree pointed_to_1 = TREE_TYPE (t1);
 317         tree pointed_to_2 = TREE_TYPE (t2);
 318         tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
 319                                    TYPE_MAIN_VARIANT (pointed_to_2));
 320         t1 = build_pointer_type (c_build_qualified_type
 321                                  (target,
 322                                   TYPE_QUALS (pointed_to_1) |
 323                                   TYPE_QUALS (pointed_to_2)));
 324         return build_type_attribute_variant (t1, attributes);
 325       }
 326
 327     case ARRAY_TYPE:
 328       {
 329         tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
 330         /* Save space: see if the result is identical to one of the args.  */
 331         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
 332           return build_type_attribute_variant (t1, attributes);
 333         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
 334           return build_type_attribute_variant (t2, attributes);
 335         /* Merge the element types, and have a size if either arg has one.  */
 336         t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
 337         return build_type_attribute_variant (t1, attributes);
 338       }
 339
 340     case FUNCTION_TYPE:
 341       /* Function types: prefer the one that specified arg types.
 342          If both do, merge the arg types.  Also merge the return types.  */
 343       {
 344         tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
 345         tree p1 = TYPE_ARG_TYPES (t1);
 346         tree p2 = TYPE_ARG_TYPES (t2);
 347         int len;
 348         tree newargs, n;
 349         int i;
 350
 351         /* Save space: see if the result is identical to one of the args.  */
 352         if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
 353           return build_type_attribute_variant (t1, attributes);
 354         if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
 355           return build_type_attribute_variant (t2, attributes);
 356
 357         /* Simple way if one arg fails to specify argument types.  */
 358         if (TYPE_ARG_TYPES (t1) == 0)
 359          {
 360            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 361            return build_type_attribute_variant (t1, attributes);
 362          }
 363         if (TYPE_ARG_TYPES (t2) == 0)
 364          {
 365            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 366            return build_type_attribute_variant (t1, attributes);
 367          }
 368
 369         /* If both args specify argument types, we must merge the two
 370            lists, argument by argument.  */
 371
 372         pushlevel (0);
 373         declare_parm_level ();
 374
 375         len = list_length (p1);
 376         newargs = 0;
 377
 378         for (i = 0; i < len; i++)
 379           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 380
 381         n = newargs;
 382
 383         for (; p1;
 384              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 385           {
 386             /* A null type means arg type is not specified.
 387                Take whatever the other function type has.  */
 388             if (TREE_VALUE (p1) == 0)
 389               {
 390                 TREE_VALUE (n) = TREE_VALUE (p2);
 391                 goto parm_done;
 392               }
 393             if (TREE_VALUE (p2) == 0)
 394               {
 395                 TREE_VALUE (n) = TREE_VALUE (p1);
 396                 goto parm_done;
 397               }
 398
 399             /* Given  wait (union {union wait *u; int *i} *)
 400                and  wait (union wait *),
 401                prefer  union wait *  as type of parm.  */
 402             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 403                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 404               {
 405                 tree memb;
 406                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 407                      memb; memb = TREE_CHAIN (memb))
 408                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2),
 409                                  COMPARE_STRICT))
 410                     {
 411                       TREE_VALUE (n) = TREE_VALUE (p2);
 412                       if (pedantic)
 413                         pedwarn ("function types not truly compatible in ISO C");
 414                       goto parm_done;
 415                     }
 416               }
 417             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 418                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 419               {
 420                 tree memb;
 421                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 422                      memb; memb = TREE_CHAIN (memb))
 423                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1),
 424                                  COMPARE_STRICT))
 425                     {
 426                       TREE_VALUE (n) = TREE_VALUE (p1);
 427                       if (pedantic)
 428                         pedwarn ("function types not truly compatible in ISO C");
 429                       goto parm_done;
 430                     }
 431               }
 432             TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
 433           parm_done: ;
 434           }
 435
 436         poplevel (0, 0, 0);
 437
 438         t1 = build_function_type (valtype, newargs);
 439         /* ... falls through ...  */
 440       }
 441
 442     default:
 443       return build_type_attribute_variant (t1, attributes);
 444     }
 445
 446 }
 447 \f
 448 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 449    or various other operations.  Return 2 if they are compatible
 450    but a warning may be needed if you use them together.  */
 451
 452 int
 453 comptypes (tree type1, tree type2, int flags)
 454 {
 455   tree t1 = type1;
 456   tree t2 = type2;
 457   int attrval, val;
 458
 459   /* Suppress errors caused by previously reported errors.  */
 460
 461   if (t1 == t2 || !t1 || !t2
 462       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
 463     return 1;
 464
 465   /* If either type is the internal version of sizetype, return the
 466      language version.  */
 467   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
 468       && TYPE_DOMAIN (t1) != 0)
 469     t1 = TYPE_DOMAIN (t1);
 470
 471   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
 472       && TYPE_DOMAIN (t2) != 0)
 473     t2 = TYPE_DOMAIN (t2);
 474
 475   /* Enumerated types are compatible with integer types, but this is
 476      not transitive: two enumerated types in the same translation unit
 477      are compatible with each other only if they are the same type.  */
 478
 479   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
 480     t1 = c_common_type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
 481   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
 482     t2 = c_common_type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
 483
 484   if (t1 == t2)
 485     return 1;
 486
 487   /* Different classes of types can't be compatible.  */
 488
 489   if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
 490
 491   /* Qualifiers must match.  */
 492
 493   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
 494     return 0;
 495
 496   /* Allow for two different type nodes which have essentially the same
 497      definition.  Note that we already checked for equality of the type
 498      qualifiers (just above).  */
 499
 500   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 501     return 1;
 502
 503   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 504   if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
 505      return 0;
 506
 507   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 508   val = 0;
 509
 510   switch (TREE_CODE (t1))
 511     {
 512     case POINTER_TYPE:
 513       /* We must give ObjC the first crack at comparing pointers, since
 514            protocol qualifiers may be involved.  */
 515       if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
 516         break;
 517       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
 518              ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2), flags));
 519       break;
 520
 521     case FUNCTION_TYPE:
 522       val = function_types_compatible_p (t1, t2, flags);
 523       break;
 524
 525     case ARRAY_TYPE:
 526       {
 527         tree d1 = TYPE_DOMAIN (t1);
 528         tree d2 = TYPE_DOMAIN (t2);
 529         bool d1_variable, d2_variable;
 530         bool d1_zero, d2_zero;
 531         val = 1;
 532
 533         /* Target types must match incl. qualifiers.  */
 534         if (TREE_TYPE (t1) != TREE_TYPE (t2)
 535             && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2),
 536                                       flags)))
 537           return 0;
 538
 539         /* Sizes must match unless one is missing or variable.  */
 540         if (d1 == 0 || d2 == 0 || d1 == d2)
 541           break;
 542
 543         d1_zero = ! TYPE_MAX_VALUE (d1);
 544         d2_zero = ! TYPE_MAX_VALUE (d2);
 545
 546         d1_variable = (! d1_zero
 547                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 548                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 549         d2_variable = (! d2_zero
 550                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 551                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 552
 553         if (d1_variable || d2_variable)
 554           break;
 555         if (d1_zero && d2_zero)
 556           break;
 557         if (d1_zero || d2_zero
 558             || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
 559             || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
 560           val = 0;
 561
 562         break;
 563       }
 564
 565     case RECORD_TYPE:
 566       /* We are dealing with two distinct structs.  In assorted Objective-C
 567          corner cases, however, these can still be deemed equivalent.  */
 568       if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
 569         val = 1;
 570
 571     case ENUMERAL_TYPE:
 572     case UNION_TYPE:
 573       if (val != 1 && !same_translation_unit_p (t1, t2))
 574         val = tagged_types_tu_compatible_p (t1, t2, flags);
 575       break;
 576
 577     case VECTOR_TYPE:
 578       /* The target might allow certain vector types to be compatible.  */
 579       val = (*targetm.vector_opaque_p) (t1)
 580         || (*targetm.vector_opaque_p) (t2);
 581       break;
 582
 583     default:
 584       break;
 585     }
 586   return attrval == 2 && val == 1 ? 2 : val;
 587 }
 588
 589 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
 590    ignoring their qualifiers.  REFLEXIVE is only used by ObjC - set it
 591    to 1 or 0 depending if the check of the pointer types is meant to
 592    be reflexive or not (typically, assignments are not reflexive,
 593    while comparisons are reflexive).
 594 */
 595
 596 static int
 597 comp_target_types (tree ttl, tree ttr, int reflexive)
 598 {
 599   int val;
 600
 601   /* Give objc_comptypes a crack at letting these types through.  */
 602   if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
 603     return val;
 604
 605   val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
 606                    TYPE_MAIN_VARIANT (TREE_TYPE (ttr)), COMPARE_STRICT);
 607
 608   if (val == 2 && pedantic)
 609     pedwarn ("types are not quite compatible");
 610   return val;
 611 }
 612 \f
 613 /* Subroutines of `comptypes'.  */
 614
 615 /* Determine whether two types derive from the same translation unit.
 616    If the CONTEXT chain ends in a null, that type's context is still
 617    being parsed, so if two types have context chains ending in null,
 618    they're in the same translation unit.  */
 619 static int
 620 same_translation_unit_p (tree t1, tree t2)
 621 {
 622   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
 623     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
 624       {
 625       case 'd': t1 = DECL_CONTEXT (t1); break;
 626       case 't': t1 = TYPE_CONTEXT (t1); break;
 627       case 'b': t1 = BLOCK_SUPERCONTEXT (t1); break;
 628       default: abort ();
 629       }
 630
 631   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
 632     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
 633       {
 634       case 'd': t2 = DECL_CONTEXT (t1); break;
 635       case 't': t2 = TYPE_CONTEXT (t2); break;
 636       case 'b': t2 = BLOCK_SUPERCONTEXT (t2); break;
 637       default: abort ();
 638       }
 639
 640   return t1 == t2;
 641 }
 642
 643 /* The C standard says that two structures in different translation
 644    units are compatible with each other only if the types of their
 645    fields are compatible (among other things).  So, consider two copies
 646    of this structure:  */
 647
 648 struct tagged_tu_seen {
 649   const struct tagged_tu_seen * next;
 650   tree t1;
 651   tree t2;
 652 };
 653
 654 /* Can they be compatible with each other?  We choose to break the
 655    recursion by allowing those types to be compatible.  */
 656
 657 static const struct tagged_tu_seen * tagged_tu_seen_base;
 658
 659 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
 660    compatible.  If the two types are not the same (which has been
 661    checked earlier), this can only happen when multiple translation
 662    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
 663    rules.  */
 664
 665 static int
 666 tagged_types_tu_compatible_p (tree t1, tree t2, int flags)
 667 {
 668   tree s1, s2;
 669   bool needs_warning = false;
 670
 671   /* We have to verify that the tags of the types are the same.  This
 672      is harder than it looks because this may be a typedef, so we have
 673      to go look at the original type.  It may even be a typedef of a
 674      typedef...  */
 675   while (TYPE_NAME (t1) && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL)
 676     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
 677
 678   while (TYPE_NAME (t2) && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL)
 679     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
 680
 681   /* C90 didn't have the requirement that the two tags be the same.  */
 682   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
 683     return 0;
 684
 685   /* C90 didn't say what happened if one or both of the types were
 686      incomplete; we choose to follow C99 rules here, which is that they
 687      are compatible.  */
 688   if (TYPE_SIZE (t1) == NULL
 689       || TYPE_SIZE (t2) == NULL)
 690     return 1;
 691
 692   {
 693     const struct tagged_tu_seen * tts_i;
 694     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
 695       if (tts_i->t1 == t1 && tts_i->t2 == t2)
 696         return 1;
 697   }
 698
 699   switch (TREE_CODE (t1))
 700     {
 701     case ENUMERAL_TYPE:
 702       {
 703         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
 704           return 0;
 705
 706         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
 707           {
 708             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
 709             if (s2 == NULL
 710                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
 711               return 0;
 712           }
 713         return 1;
 714       }
 715
 716     case UNION_TYPE:
 717       {
 718         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
 719           return 0;
 720
 721         for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
 722           {
 723             bool ok = false;
 724             struct tagged_tu_seen tts;
 725
 726             tts.next = tagged_tu_seen_base;
 727             tts.t1 = t1;
 728             tts.t2 = t2;
 729             tagged_tu_seen_base = &tts;
 730
 731             if (DECL_NAME (s1) != NULL)
 732               for (s2 = TYPE_VALUES (t2); s2; s2 = TREE_CHAIN (s2))
 733                 if (DECL_NAME (s1) == DECL_NAME (s2))
 734                   {
 735                     int result;
 736                     result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags);
 737                     if (result == 0)
 738                       break;
 739                     if (result == 2)
 740                       needs_warning = true;
 741
 742                     if (TREE_CODE (s1) == FIELD_DECL
 743                         && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
 744                                              DECL_FIELD_BIT_OFFSET (s2)) != 1)
 745                       break;
 746
 747                     ok = true;
 748                     break;
 749                   }
 750             tagged_tu_seen_base = tts.next;
 751             if (! ok)
 752               return 0;
 753           }
 754         return needs_warning ? 2 : 1;
 755       }
 756
 757     case RECORD_TYPE:
 758       {
 759         struct tagged_tu_seen tts;
 760
 761         tts.next = tagged_tu_seen_base;
 762         tts.t1 = t1;
 763         tts.t2 = t2;
 764         tagged_tu_seen_base = &tts;
 765
 766         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
 767              s1 && s2;
 768              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
 769           {
 770             int result;
 771             if (TREE_CODE (s1) != TREE_CODE (s2)
 772                 || DECL_NAME (s1) != DECL_NAME (s2))
 773               break;
 774             result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags);
 775             if (result == 0)
 776               break;
 777             if (result == 2)
 778               needs_warning = true;
 779
 780             if (TREE_CODE (s1) == FIELD_DECL
 781                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
 782                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
 783               break;
 784           }
 785         tagged_tu_seen_base = tts.next;
 786         if (s1 && s2)
 787           return 0;
 788         return needs_warning ? 2 : 1;
 789       }
 790
 791     default:
 792       abort ();
 793     }
 794 }
 795
 796 /* Return 1 if two function types F1 and F2 are compatible.
 797    If either type specifies no argument types,
 798    the other must specify a fixed number of self-promoting arg types.
 799    Otherwise, if one type specifies only the number of arguments,
 800    the other must specify that number of self-promoting arg types.
 801    Otherwise, the argument types must match.  */
 802
 803 static int
 804 function_types_compatible_p (tree f1, tree f2, int flags)
 805 {
 806   tree args1, args2;
 807   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 808   int val = 1;
 809   int val1;
 810   tree ret1, ret2;
 811
 812   ret1 = TREE_TYPE (f1);
 813   ret2 = TREE_TYPE (f2);
 814
 815   /* 'volatile' qualifiers on a function's return type mean the function
 816      is noreturn.  */
 817   if (pedantic && TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
 818     pedwarn ("function return types not compatible due to `volatile'");
 819   if (TYPE_VOLATILE (ret1))
 820     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
 821                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
 822   if (TYPE_VOLATILE (ret2))
 823     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
 824                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
 825   val = comptypes (ret1, ret2, flags);
 826   if (val == 0)
 827     return 0;
 828
 829   args1 = TYPE_ARG_TYPES (f1);
 830   args2 = TYPE_ARG_TYPES (f2);
 831
 832   /* An unspecified parmlist matches any specified parmlist
 833      whose argument types don't need default promotions.  */
 834
 835   if (args1 == 0)
 836     {
 837       if (!self_promoting_args_p (args2))
 838         return 0;
 839       /* If one of these types comes from a non-prototype fn definition,
 840          compare that with the other type's arglist.
 841          If they don't match, ask for a warning (but no error).  */
 842       if (TYPE_ACTUAL_ARG_TYPES (f1)
 843           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
 844                                            flags))
 845         val = 2;
 846       return val;
 847     }
 848   if (args2 == 0)
 849     {
 850       if (!self_promoting_args_p (args1))
 851         return 0;
 852       if (TYPE_ACTUAL_ARG_TYPES (f2)
 853           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
 854                                            flags))
 855         val = 2;
 856       return val;
 857     }
 858
 859   /* Both types have argument lists: compare them and propagate results.  */
 860   val1 = type_lists_compatible_p (args1, args2, flags);
 861   return val1 != 1 ? val1 : val;
 862 }
 863
 864 /* Check two lists of types for compatibility,
 865    returning 0 for incompatible, 1 for compatible,
 866    or 2 for compatible with warning.  */
 867
 868 static int
 869 type_lists_compatible_p (tree args1, tree args2, int flags)
 870 {
 871   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 872   int val = 1;
 873   int newval = 0;
 874
 875   while (1)
 876     {
 877       if (args1 == 0 && args2 == 0)
 878         return val;
 879       /* If one list is shorter than the other,
 880          they fail to match.  */
 881       if (args1 == 0 || args2 == 0)
 882         return 0;
 883       /* A null pointer instead of a type
 884          means there is supposed to be an argument
 885          but nothing is specified about what type it has.
 886          So match anything that self-promotes.  */
 887       if (TREE_VALUE (args1) == 0)
 888         {
 889           if (c_type_promotes_to (TREE_VALUE (args2)) != TREE_VALUE (args2))
 890             return 0;
 891         }
 892       else if (TREE_VALUE (args2) == 0)
 893         {
 894           if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
 895             return 0;
 896         }
 897       /* If one of the lists has an error marker, ignore this arg.  */
 898       else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
 899                || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
 900         ;
 901       else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
 902                                       TYPE_MAIN_VARIANT (TREE_VALUE (args2)),
 903                                       flags)))
 904         {
 905           /* Allow  wait (union {union wait *u; int *i} *)
 906              and  wait (union wait *)  to be compatible.  */
 907           if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
 908               && (TYPE_NAME (TREE_VALUE (args1)) == 0
 909                   || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
 910               && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
 911               && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
 912                                      TYPE_SIZE (TREE_VALUE (args2))))
 913             {
 914               tree memb;
 915               for (memb = TYPE_FIELDS (TREE_VALUE (args1));
 916                    memb; memb = TREE_CHAIN (memb))
 917                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2),
 918                                flags))
 919                   break;
 920               if (memb == 0)
 921                 return 0;
 922             }
 923           else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
 924                    && (TYPE_NAME (TREE_VALUE (args2)) == 0
 925                        || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
 926                    && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
 927                    && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
 928                                           TYPE_SIZE (TREE_VALUE (args1))))
 929             {
 930               tree memb;
 931               for (memb = TYPE_FIELDS (TREE_VALUE (args2));
 932                    memb; memb = TREE_CHAIN (memb))
 933                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1),
 934                                flags))
 935                   break;
 936               if (memb == 0)
 937                 return 0;
 938             }
 939           else
 940             return 0;
 941         }
 942
 943       /* comptypes said ok, but record if it said to warn.  */
 944       if (newval > val)
 945         val = newval;
 946
 947       args1 = TREE_CHAIN (args1);
 948       args2 = TREE_CHAIN (args2);
 949     }
 950 }
 951 \f
 952 /* Compute the size to increment a pointer by.  */
 953
 954 tree
 955 c_size_in_bytes (tree type)
 956 {
 957   enum tree_code code = TREE_CODE (type);
 958
 959   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
 960     return size_one_node;
 961
 962   if (!COMPLETE_OR_VOID_TYPE_P (type))
 963     {
 964       error ("arithmetic on pointer to an incomplete type");
 965       return size_one_node;
 966     }
 967
 968   /* Convert in case a char is more than one unit.  */
 969   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
 970                      size_int (TYPE_PRECISION (char_type_node)
 971                                / BITS_PER_UNIT));
 972 }
 973 \f
 974 /* Return either DECL or its known constant value (if it has one).  */
 975
 976 tree
 977 decl_constant_value (tree decl)
 978 {
 979   if (/* Don't change a variable array bound or initial value to a constant
 980          in a place where a variable is invalid.  */
 981       current_function_decl != 0
 982       && ! TREE_THIS_VOLATILE (decl)
 983       && TREE_READONLY (decl)
 984       && DECL_INITIAL (decl) != 0
 985       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 986       /* This is invalid if initial value is not constant.
 987          If it has either a function call, a memory reference,
 988          or a variable, then re-evaluating it could give different results.  */
 989       && TREE_CONSTANT (DECL_INITIAL (decl))
 990       /* Check for cases where this is sub-optimal, even though valid.  */
 991       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 992     return DECL_INITIAL (decl);
 993   return decl;
 994 }
 995
 996 /* Return either DECL or its known constant value (if it has one), but
 997    return DECL if pedantic or DECL has mode BLKmode.  This is for
 998    bug-compatibility with the old behavior of decl_constant_value
 999    (before GCC 3.0); every use of this function is a bug and it should
1000    be removed before GCC 3.1.  It is not appropriate to use pedantic
1001    in a way that affects optimization, and BLKmode is probably not the
1002    right test for avoiding misoptimizations either.  */
1003
1004 static tree
1005 decl_constant_value_for_broken_optimization (tree decl)
1006 {
1007   if (pedantic || DECL_MODE (decl) == BLKmode)
1008     return decl;
1009   else
1010     return decl_constant_value (decl);
1011 }
1012
1013
1014 /* Perform the default conversion of arrays and functions to pointers.
1015    Return the result of converting EXP.  For any other expression, just
1016    return EXP.  */
1017
1018 static tree
1019 default_function_array_conversion (tree exp)
1020 {
1021   tree orig_exp;
1022   tree type = TREE_TYPE (exp);
1023   enum tree_code code = TREE_CODE (type);
1024   int not_lvalue = 0;
1025
1026   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1027      an lvalue.
1028
1029      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1030      to integer and cause infinite recursion.  */
1031   orig_exp = exp;
1032   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1033          || (TREE_CODE (exp) == NOP_EXPR
1034              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1035     {
1036       if (TREE_CODE (exp) == NON_LVALUE_EXPR)
1037         not_lvalue = 1;
1038       exp = TREE_OPERAND (exp, 0);
1039     }
1040
1041   /* Preserve the original expression code.  */
1042   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
1043     C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
1044
1045   if (code == FUNCTION_TYPE)
1046     {
1047       return build_unary_op (ADDR_EXPR, exp, 0);
1048     }
1049   if (code == ARRAY_TYPE)
1050     {
1051       tree adr;
1052       tree restype = TREE_TYPE (type);
1053       tree ptrtype;
1054       int constp = 0;
1055       int volatilep = 0;
1056       int lvalue_array_p;
1057
1058       if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
1059         {
1060           constp = TREE_READONLY (exp);
1061           volatilep = TREE_THIS_VOLATILE (exp);
1062         }
1063
1064       if (TYPE_QUALS (type) || constp || volatilep)
1065         restype
1066           = c_build_qualified_type (restype,
1067                                     TYPE_QUALS (type)
1068                                     | (constp * TYPE_QUAL_CONST)
1069                                     | (volatilep * TYPE_QUAL_VOLATILE));
1070
1071       if (TREE_CODE (exp) == INDIRECT_REF)
1072         return convert (TYPE_POINTER_TO (restype),
1073                         TREE_OPERAND (exp, 0));
1074
1075       if (TREE_CODE (exp) == COMPOUND_EXPR)
1076         {
1077           tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1078           return build (COMPOUND_EXPR, TREE_TYPE (op1),
1079                         TREE_OPERAND (exp, 0), op1);
1080         }
1081
1082       lvalue_array_p = !not_lvalue && lvalue_p (exp);
1083       if (!flag_isoc99 && !lvalue_array_p)
1084         {
1085           /* Before C99, non-lvalue arrays do not decay to pointers.
1086              Normally, using such an array would be invalid; but it can
1087              be used correctly inside sizeof or as a statement expression.
1088              Thus, do not give an error here; an error will result later.  */
1089           return exp;
1090         }
1091
1092       ptrtype = build_pointer_type (restype);
1093
1094       if (TREE_CODE (exp) == VAR_DECL)
1095         {
1096           /* ??? This is not really quite correct
1097              in that the type of the operand of ADDR_EXPR
1098              is not the target type of the type of the ADDR_EXPR itself.
1099              Question is, can this lossage be avoided?  */
1100           adr = build1 (ADDR_EXPR, ptrtype, exp);
1101           if (!c_mark_addressable (exp))
1102             return error_mark_node;
1103           TREE_CONSTANT (adr) = staticp (exp);
1104           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1105           return adr;
1106         }
1107       /* This way is better for a COMPONENT_REF since it can
1108          simplify the offset for a component.  */
1109       adr = build_unary_op (ADDR_EXPR, exp, 1);
1110       return convert (ptrtype, adr);
1111     }
1112   return exp;
1113 }
1114
1115 /* Perform default promotions for C data used in expressions.
1116    Arrays and functions are converted to pointers;
1117    enumeral types or short or char, to int.
1118    In addition, manifest constants symbols are replaced by their values.  */
1119
1120 tree
1121 default_conversion (tree exp)
1122 {
1123   tree orig_exp;
1124   tree type = TREE_TYPE (exp);
1125   enum tree_code code = TREE_CODE (type);
1126
1127   if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
1128     return default_function_array_conversion (exp);
1129
1130   /* Constants can be used directly unless they're not loadable.  */
1131   if (TREE_CODE (exp) == CONST_DECL)
1132     exp = DECL_INITIAL (exp);
1133
1134   /* Replace a nonvolatile const static variable with its value unless
1135      it is an array, in which case we must be sure that taking the
1136      address of the array produces consistent results.  */
1137   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1138     {
1139       exp = decl_constant_value_for_broken_optimization (exp);
1140       type = TREE_TYPE (exp);
1141     }
1142
1143   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1144      an lvalue.
1145
1146      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1147      to integer and cause infinite recursion.  */
1148   orig_exp = exp;
1149   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1150          || (TREE_CODE (exp) == NOP_EXPR
1151              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1152     exp = TREE_OPERAND (exp, 0);
1153
1154   /* Preserve the original expression code.  */
1155   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
1156     C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
1157
1158   /* Normally convert enums to int,
1159      but convert wide enums to something wider.  */
1160   if (code == ENUMERAL_TYPE)
1161     {
1162       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1163                                           TYPE_PRECISION (integer_type_node)),
1164                                      ((TYPE_PRECISION (type)
1165                                        >= TYPE_PRECISION (integer_type_node))
1166                                       && TREE_UNSIGNED (type)));
1167
1168       return convert (type, exp);
1169     }
1170
1171   if (TREE_CODE (exp) == COMPONENT_REF
1172       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1173       /* If it's thinner than an int, promote it like a
1174          c_promoting_integer_type_p, otherwise leave it alone.  */
1175       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1176                                TYPE_PRECISION (integer_type_node)))
1177     return convert (integer_type_node, exp);
1178
1179   if (c_promoting_integer_type_p (type))
1180     {
1181       /* Preserve unsignedness if not really getting any wider.  */
1182       if (TREE_UNSIGNED (type)
1183           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1184         return convert (unsigned_type_node, exp);
1185
1186       return convert (integer_type_node, exp);
1187     }
1188
1189   if (code == VOID_TYPE)
1190     {
1191       error ("void value not ignored as it ought to be");
1192       return error_mark_node;
1193     }
1194   return exp;
1195 }
1196 \f
1197 /* Look up COMPONENT in a structure or union DECL.
1198
1199    If the component name is not found, returns NULL_TREE.  Otherwise,
1200    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1201    stepping down the chain to the component, which is in the last
1202    TREE_VALUE of the list.  Normally the list is of length one, but if
1203    the component is embedded within (nested) anonymous structures or
1204    unions, the list steps down the chain to the component.  */
1205
1206 static tree
1207 lookup_field (tree decl, tree component)
1208 {
1209   tree type = TREE_TYPE (decl);
1210   tree field;
1211
1212   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1213      to the field elements.  Use a binary search on this array to quickly
1214      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1215      will always be set for structures which have many elements.  */
1216
1217   if (TYPE_LANG_SPECIFIC (type))
1218     {
1219       int bot, top, half;
1220       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1221
1222       field = TYPE_FIELDS (type);
1223       bot = 0;
1224       top = TYPE_LANG_SPECIFIC (type)->s->len;
1225       while (top - bot > 1)
1226         {
1227           half = (top - bot + 1) >> 1;
1228           field = field_array[bot+half];
1229
1230           if (DECL_NAME (field) == NULL_TREE)
1231             {
1232               /* Step through all anon unions in linear fashion.  */
1233               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1234                 {
1235                   field = field_array[bot++];
1236                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1237                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1238                     {
1239                       tree anon = lookup_field (field, component);
1240
1241                       if (anon)
1242                         return tree_cons (NULL_TREE, field, anon);
1243                     }
1244                 }
1245
1246               /* Entire record is only anon unions.  */
1247               if (bot > top)
1248                 return NULL_TREE;
1249
1250               /* Restart the binary search, with new lower bound.  */
1251               continue;
1252             }
1253
1254           if (DECL_NAME (field) == component)
1255             break;
1256           if (DECL_NAME (field) < component)
1257             bot += half;
1258           else
1259             top = bot + half;
1260         }
1261
1262       if (DECL_NAME (field_array[bot]) == component)
1263         field = field_array[bot];
1264       else if (DECL_NAME (field) != component)
1265         return NULL_TREE;
1266     }
1267   else
1268     {
1269       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1270         {
1271           if (DECL_NAME (field) == NULL_TREE
1272               && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1273                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1274             {
1275               tree anon = lookup_field (field, component);
1276
1277               if (anon)
1278                 return tree_cons (NULL_TREE, field, anon);
1279             }
1280
1281           if (DECL_NAME (field) == component)
1282             break;
1283         }
1284
1285       if (field == NULL_TREE)
1286         return NULL_TREE;
1287     }
1288
1289   return tree_cons (NULL_TREE, field, NULL_TREE);
1290 }
1291
1292 /* Make an expression to refer to the COMPONENT field of
1293    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1294
1295 tree
1296 build_component_ref (tree datum, tree component)
1297 {
1298   tree type = TREE_TYPE (datum);
1299   enum tree_code code = TREE_CODE (type);
1300   tree field = NULL;
1301   tree ref;
1302
1303   /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
1304      Ensure that the arguments are not lvalues; otherwise,
1305      if the component is an array, it would wrongly decay to a pointer in
1306      C89 mode.
1307      We cannot do this with a COND_EXPR, because in a conditional expression
1308      the default promotions are applied to both sides, and this would yield
1309      the wrong type of the result; for example, if the components have
1310      type "char".  */
1311   switch (TREE_CODE (datum))
1312     {
1313     case COMPOUND_EXPR:
1314       {
1315         tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1316         return build (COMPOUND_EXPR, TREE_TYPE (value),
1317                       TREE_OPERAND (datum, 0), non_lvalue (value));
1318       }
1319     default:
1320       break;
1321     }
1322
1323   /* See if there is a field or component with name COMPONENT.  */
1324
1325   if (code == RECORD_TYPE || code == UNION_TYPE)
1326     {
1327       if (!COMPLETE_TYPE_P (type))
1328         {
1329           c_incomplete_type_error (NULL_TREE, type);
1330           return error_mark_node;
1331         }
1332
1333       field = lookup_field (datum, component);
1334
1335       if (!field)
1336         {
1337           error ("%s has no member named `%s'",
1338                  code == RECORD_TYPE ? "structure" : "union",
1339                  IDENTIFIER_POINTER (component));
1340           return error_mark_node;
1341         }
1342
1343       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1344          This might be better solved in future the way the C++ front
1345          end does it - by giving the anonymous entities each a
1346          separate name and type, and then have build_component_ref
1347          recursively call itself.  We can't do that here.  */
1348       do
1349         {
1350           tree subdatum = TREE_VALUE (field);
1351
1352           if (TREE_TYPE (subdatum) == error_mark_node)
1353             return error_mark_node;
1354
1355           ref = build (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum);
1356           if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1357             TREE_READONLY (ref) = 1;
1358           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1359             TREE_THIS_VOLATILE (ref) = 1;
1360
1361           if (TREE_DEPRECATED (subdatum))
1362             warn_deprecated_use (subdatum);
1363
1364           datum = ref;
1365
1366           field = TREE_CHAIN (field);
1367         }
1368       while (field);
1369
1370       return ref;
1371     }
1372   else if (code != ERROR_MARK)
1373     error ("request for member `%s' in something not a structure or union",
1374             IDENTIFIER_POINTER (component));
1375
1376   return error_mark_node;
1377 }
1378 \f
1379 /* Given an expression PTR for a pointer, return an expression
1380    for the value pointed to.
1381    ERRORSTRING is the name of the operator to appear in error messages.  */
1382
1383 tree
1384 build_indirect_ref (tree ptr, const char *errorstring)
1385 {
1386   tree pointer = default_conversion (ptr);
1387   tree type = TREE_TYPE (pointer);
1388
1389   if (TREE_CODE (type) == POINTER_TYPE)
1390     {
1391       if (TREE_CODE (pointer) == ADDR_EXPR
1392           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1393               == TREE_TYPE (type)))
1394         return TREE_OPERAND (pointer, 0);
1395       else
1396         {
1397           tree t = TREE_TYPE (type);
1398           tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1399
1400           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1401             {
1402               error ("dereferencing pointer to incomplete type");
1403               return error_mark_node;
1404             }
1405           if (VOID_TYPE_P (t) && skip_evaluation == 0)
1406             warning ("dereferencing `void *' pointer");
1407
1408           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1409              so that we get the proper error message if the result is used
1410              to assign to.  Also, &* is supposed to be a no-op.
1411              And ANSI C seems to specify that the type of the result
1412              should be the const type.  */
1413           /* A de-reference of a pointer to const is not a const.  It is valid
1414              to change it via some other pointer.  */
1415           TREE_READONLY (ref) = TYPE_READONLY (t);
1416           TREE_SIDE_EFFECTS (ref)
1417             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1418           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1419           return ref;
1420         }
1421     }
1422   else if (TREE_CODE (pointer) != ERROR_MARK)
1423     error ("invalid type argument of `%s'", errorstring);
1424   return error_mark_node;
1425 }
1426
1427 /* This handles expressions of the form "a[i]", which denotes
1428    an array reference.
1429
1430    This is logically equivalent in C to *(a+i), but we may do it differently.
1431    If A is a variable or a member, we generate a primitive ARRAY_REF.
1432    This avoids forcing the array out of registers, and can work on
1433    arrays that are not lvalues (for example, members of structures returned
1434    by functions).  */
1435
1436 tree
1437 build_array_ref (tree array, tree index)
1438 {
1439   if (index == 0)
1440     {
1441       error ("subscript missing in array reference");
1442       return error_mark_node;
1443     }
1444
1445   if (TREE_TYPE (array) == error_mark_node
1446       || TREE_TYPE (index) == error_mark_node)
1447     return error_mark_node;
1448
1449   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1450       && TREE_CODE (array) != INDIRECT_REF)
1451     {
1452       tree rval, type;
1453
1454       /* Subscripting with type char is likely to lose
1455          on a machine where chars are signed.
1456          So warn on any machine, but optionally.
1457          Don't warn for unsigned char since that type is safe.
1458          Don't warn for signed char because anyone who uses that
1459          must have done so deliberately.  */
1460       if (warn_char_subscripts
1461           && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1462         warning ("array subscript has type `char'");
1463
1464       /* Apply default promotions *after* noticing character types.  */
1465       index = default_conversion (index);
1466
1467       /* Require integer *after* promotion, for sake of enums.  */
1468       if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1469         {
1470           error ("array subscript is not an integer");
1471           return error_mark_node;
1472         }
1473
1474       /* An array that is indexed by a non-constant
1475          cannot be stored in a register; we must be able to do
1476          address arithmetic on its address.
1477          Likewise an array of elements of variable size.  */
1478       if (TREE_CODE (index) != INTEGER_CST
1479           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1480               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1481         {
1482           if (!c_mark_addressable (array))
1483             return error_mark_node;
1484         }
1485       /* An array that is indexed by a constant value which is not within
1486          the array bounds cannot be stored in a register either; because we
1487          would get a crash in store_bit_field/extract_bit_field when trying
1488          to access a non-existent part of the register.  */
1489       if (TREE_CODE (index) == INTEGER_CST
1490           && TYPE_VALUES (TREE_TYPE (array))
1491           && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1492         {
1493           if (!c_mark_addressable (array))
1494             return error_mark_node;
1495         }
1496
1497       if (pedantic)
1498         {
1499           tree foo = array;
1500           while (TREE_CODE (foo) == COMPONENT_REF)
1501             foo = TREE_OPERAND (foo, 0);
1502           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1503             pedwarn ("ISO C forbids subscripting `register' array");
1504           else if (! flag_isoc99 && ! lvalue_p (foo))
1505             pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1506         }
1507
1508       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1509       rval = build (ARRAY_REF, type, array, index);
1510       /* Array ref is const/volatile if the array elements are
1511          or if the array is.  */
1512       TREE_READONLY (rval)
1513         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1514             | TREE_READONLY (array));
1515       TREE_SIDE_EFFECTS (rval)
1516         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1517             | TREE_SIDE_EFFECTS (array));
1518       TREE_THIS_VOLATILE (rval)
1519         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1520             /* This was added by rms on 16 Nov 91.
1521                It fixes  vol struct foo *a;  a->elts[1]
1522                in an inline function.
1523                Hope it doesn't break something else.  */
1524             | TREE_THIS_VOLATILE (array));
1525       return require_complete_type (fold (rval));
1526     }
1527
1528   {
1529     tree ar = default_conversion (array);
1530     tree ind = default_conversion (index);
1531
1532     /* Do the same warning check as above, but only on the part that's
1533        syntactically the index and only if it is also semantically
1534        the index.  */
1535     if (warn_char_subscripts
1536         && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1537         && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1538       warning ("subscript has type `char'");
1539
1540     /* Put the integer in IND to simplify error checking.  */
1541     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1542       {
1543         tree temp = ar;
1544         ar = ind;
1545         ind = temp;
1546       }
1547
1548     if (ar == error_mark_node)
1549       return ar;
1550
1551     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1552         || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1553       {
1554         error ("subscripted value is neither array nor pointer");
1555         return error_mark_node;
1556       }
1557     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1558       {
1559         error ("array subscript is not an integer");
1560         return error_mark_node;
1561       }
1562
1563     return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1564                                "array indexing");
1565   }
1566 }
1567 \f
1568 /* Build an external reference to identifier ID.  FUN indicates
1569    whether this will be used for a function call.  */
1570 tree
1571 build_external_ref (tree id, int fun)
1572 {
1573   tree ref;
1574   tree decl = lookup_name (id);
1575   tree objc_ivar = lookup_objc_ivar (id);
1576
1577   if (decl && decl != error_mark_node)
1578     {
1579       /* Properly declared variable or function reference.  */
1580       if (!objc_ivar)
1581         ref = decl;
1582       else if (decl != objc_ivar && !DECL_FILE_SCOPE_P (decl))
1583         {
1584           warning ("local declaration of `%s' hides instance variable",
1585                    IDENTIFIER_POINTER (id));
1586           ref = decl;
1587         }
1588       else
1589         ref = objc_ivar;
1590     }
1591   else if (objc_ivar)
1592     ref = objc_ivar;
1593   else if (fun)
1594     /* Implicit function declaration.  */
1595     ref = implicitly_declare (id);
1596   else if (decl == error_mark_node)
1597     /* Don't complain about something that's already been
1598        complained about.  */
1599     return error_mark_node;
1600   else
1601     {
1602       undeclared_variable (id);
1603       return error_mark_node;
1604     }
1605
1606   if (TREE_TYPE (ref) == error_mark_node)
1607     return error_mark_node;
1608
1609   if (TREE_DEPRECATED (ref))
1610     warn_deprecated_use (ref);
1611
1612   if (!skip_evaluation)
1613     assemble_external (ref);
1614   TREE_USED (ref) = 1;
1615
1616   if (TREE_CODE (ref) == CONST_DECL)
1617     {
1618       ref = DECL_INITIAL (ref);
1619       TREE_CONSTANT (ref) = 1;
1620     }
1621   else if (current_function_decl != 0
1622            && !DECL_FILE_SCOPE_P (current_function_decl)
1623            && (TREE_CODE (ref) == VAR_DECL
1624                || TREE_CODE (ref) == PARM_DECL
1625                || TREE_CODE (ref) == FUNCTION_DECL))
1626     {
1627       tree context = decl_function_context (ref);
1628
1629       if (context != 0 && context != current_function_decl)
1630         DECL_NONLOCAL (ref) = 1;
1631     }
1632
1633   return ref;
1634 }
1635
1636 /* Build a function call to function FUNCTION with parameters PARAMS.
1637    PARAMS is a list--a chain of TREE_LIST nodes--in which the
1638    TREE_VALUE of each node is a parameter-expression.
1639    FUNCTION's data type may be a function type or a pointer-to-function.  */
1640
1641 tree
1642 build_function_call (tree function, tree params)
1643 {
1644   tree fntype, fundecl = 0;
1645   tree coerced_params;
1646   tree name = NULL_TREE, result;
1647   tree tem;
1648
1649   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1650   STRIP_TYPE_NOPS (function);
1651
1652   /* Convert anything with function type to a pointer-to-function.  */
1653   if (TREE_CODE (function) == FUNCTION_DECL)
1654     {
1655       name = DECL_NAME (function);
1656
1657       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1658          (because calling an inline function does not mean the function
1659          needs to be separately compiled).  */
1660       fntype = build_type_variant (TREE_TYPE (function),
1661                                    TREE_READONLY (function),
1662                                    TREE_THIS_VOLATILE (function));
1663       fundecl = function;
1664       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1665     }
1666   else
1667     function = default_conversion (function);
1668
1669   fntype = TREE_TYPE (function);
1670
1671   if (TREE_CODE (fntype) == ERROR_MARK)
1672     return error_mark_node;
1673
1674   if (!(TREE_CODE (fntype) == POINTER_TYPE
1675         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1676     {
1677       error ("called object is not a function");
1678       return error_mark_node;
1679     }
1680
1681   if (fundecl && TREE_THIS_VOLATILE (fundecl))
1682     current_function_returns_abnormally = 1;
1683
1684   /* fntype now gets the type of function pointed to.  */
1685   fntype = TREE_TYPE (fntype);
1686
1687   /* Check that the function is called through a compatible prototype.
1688      If it is not, replace the call by a trap, wrapped up in a compound
1689      expression if necessary.  This has the nice side-effect to prevent
1690      the tree-inliner from generating invalid assignment trees which may
1691      blow up in the RTL expander later.
1692
1693      ??? This doesn't work for Objective-C because objc_comptypes
1694      refuses to compare function prototypes, yet the compiler appears
1695      to build calls that are flagged as invalid by C's comptypes.  */
1696   if (! c_dialect_objc ()
1697       && TREE_CODE (function) == NOP_EXPR
1698       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
1699       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
1700       && ! comptypes (fntype, TREE_TYPE (tem), COMPARE_STRICT))
1701     {
1702       tree return_type = TREE_TYPE (fntype);
1703       tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
1704                                        NULL_TREE);
1705
1706       /* This situation leads to run-time undefined behavior.  We can't,
1707          therefore, simply error unless we can prove that all possible
1708          executions of the program must execute the code.  */
1709       warning ("function called through a non-compatible type");
1710
1711       if (VOID_TYPE_P (return_type))
1712         return trap;
1713       else
1714         {
1715           tree rhs;
1716
1717           if (AGGREGATE_TYPE_P (return_type))
1718             rhs = build_compound_literal (return_type,
1719                                           build_constructor (return_type,
1720                                                              NULL_TREE));
1721           else
1722             rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
1723
1724           return build (COMPOUND_EXPR, return_type, trap, rhs);
1725         }
1726     }
1727
1728   /* Convert the parameters to the types declared in the
1729      function prototype, or apply default promotions.  */
1730
1731   coerced_params
1732     = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1733
1734   /* Check that the arguments to the function are valid.  */
1735
1736   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
1737
1738   /* Recognize certain built-in functions so we can make tree-codes
1739      other than CALL_EXPR.  We do this when it enables fold-const.c
1740      to do something useful.  */
1741
1742   if (TREE_CODE (function) == ADDR_EXPR
1743       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1744       && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1745     {
1746       result = expand_tree_builtin (TREE_OPERAND (function, 0),
1747                                     params, coerced_params);
1748       if (result)
1749         return result;
1750     }
1751
1752   result = build (CALL_EXPR, TREE_TYPE (fntype),
1753                   function, coerced_params, NULL_TREE);
1754   TREE_SIDE_EFFECTS (result) = 1;
1755   result = fold (result);
1756
1757   if (VOID_TYPE_P (TREE_TYPE (result)))
1758     return result;
1759   return require_complete_type (result);
1760 }
1761 \f
1762 /* Convert the argument expressions in the list VALUES
1763    to the types in the list TYPELIST.  The result is a list of converted
1764    argument expressions.
1765
1766    If TYPELIST is exhausted, or when an element has NULL as its type,
1767    perform the default conversions.
1768
1769    PARMLIST is the chain of parm decls for the function being called.
1770    It may be 0, if that info is not available.
1771    It is used only for generating error messages.
1772
1773    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
1774
1775    This is also where warnings about wrong number of args are generated.
1776
1777    Both VALUES and the returned value are chains of TREE_LIST nodes
1778    with the elements of the list in the TREE_VALUE slots of those nodes.  */
1779
1780 static tree
1781 convert_arguments (tree typelist, tree values, tree name, tree fundecl)
1782 {
1783   tree typetail, valtail;
1784   tree result = NULL;
1785   int parmnum;
1786
1787   /* Scan the given expressions and types, producing individual
1788      converted arguments and pushing them on RESULT in reverse order.  */
1789
1790   for (valtail = values, typetail = typelist, parmnum = 0;
1791        valtail;
1792        valtail = TREE_CHAIN (valtail), parmnum++)
1793     {
1794       tree type = typetail ? TREE_VALUE (typetail) : 0;
1795       tree val = TREE_VALUE (valtail);
1796
1797       if (type == void_type_node)
1798         {
1799           if (name)
1800             error ("too many arguments to function `%s'",
1801                    IDENTIFIER_POINTER (name));
1802           else
1803             error ("too many arguments to function");
1804           break;
1805         }
1806
1807       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1808       /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
1809          to convert automatically to a pointer.  */
1810       if (TREE_CODE (val) == NON_LVALUE_EXPR)
1811         val = TREE_OPERAND (val, 0);
1812
1813       val = default_function_array_conversion (val);
1814
1815       val = require_complete_type (val);
1816
1817       if (type != 0)
1818         {
1819           /* Formal parm type is specified by a function prototype.  */
1820           tree parmval;
1821
1822           if (!COMPLETE_TYPE_P (type))
1823             {
1824               error ("type of formal parameter %d is incomplete", parmnum + 1);
1825               parmval = val;
1826             }
1827           else
1828             {
1829               /* Optionally warn about conversions that
1830                  differ from the default conversions.  */
1831               if (warn_conversion || warn_traditional)
1832                 {
1833                   int formal_prec = TYPE_PRECISION (type);
1834
1835                   if (INTEGRAL_TYPE_P (type)
1836                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1837                     warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1838                   if (INTEGRAL_TYPE_P (type)
1839                       && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1840                     warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1841                   else if (TREE_CODE (type) == COMPLEX_TYPE
1842                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1843                     warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1844                   else if (TREE_CODE (type) == REAL_TYPE
1845                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1846                     warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1847                   else if (TREE_CODE (type) == COMPLEX_TYPE
1848                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1849                     warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1850                   else if (TREE_CODE (type) == REAL_TYPE
1851                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1852                     warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1853                   /* ??? At some point, messages should be written about
1854                      conversions between complex types, but that's too messy
1855                      to do now.  */
1856                   else if (TREE_CODE (type) == REAL_TYPE
1857                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1858                     {
1859                       /* Warn if any argument is passed as `float',
1860                          since without a prototype it would be `double'.  */
1861                       if (formal_prec == TYPE_PRECISION (float_type_node))
1862                         warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1863                     }
1864                   /* Detect integer changing in width or signedness.
1865                      These warnings are only activated with
1866                      -Wconversion, not with -Wtraditional.  */
1867                   else if (warn_conversion && INTEGRAL_TYPE_P (type)
1868                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1869                     {
1870                       tree would_have_been = default_conversion (val);
1871                       tree type1 = TREE_TYPE (would_have_been);
1872
1873                       if (TREE_CODE (type) == ENUMERAL_TYPE
1874                           && (TYPE_MAIN_VARIANT (type)
1875                               == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
1876                         /* No warning if function asks for enum
1877                            and the actual arg is that enum type.  */
1878                         ;
1879                       else if (formal_prec != TYPE_PRECISION (type1))
1880                         warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1881                       else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1882                         ;
1883                       /* Don't complain if the formal parameter type
1884                          is an enum, because we can't tell now whether
1885                          the value was an enum--even the same enum.  */
1886                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
1887                         ;
1888                       else if (TREE_CODE (val) == INTEGER_CST
1889                                && int_fits_type_p (val, type))
1890                         /* Change in signedness doesn't matter
1891                            if a constant value is unaffected.  */
1892                         ;
1893                       /* Likewise for a constant in a NOP_EXPR.  */
1894                       else if (TREE_CODE (val) == NOP_EXPR
1895                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1896                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
1897                         ;
1898                       /* If the value is extended from a narrower
1899                          unsigned type, it doesn't matter whether we
1900                          pass it as signed or unsigned; the value
1901                          certainly is the same either way.  */
1902                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1903                                && TREE_UNSIGNED (TREE_TYPE (val)))
1904                         ;
1905                       else if (TREE_UNSIGNED (type))
1906                         warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1907                       else
1908                         warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1909                     }
1910                 }
1911
1912               parmval = convert_for_assignment (type, val,
1913                                                 (char *) 0, /* arg passing  */
1914                                                 fundecl, name, parmnum + 1);
1915
1916               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
1917                   && INTEGRAL_TYPE_P (type)
1918                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1919                 parmval = default_conversion (parmval);
1920             }
1921           result = tree_cons (NULL_TREE, parmval, result);
1922         }
1923       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1924                && (TYPE_PRECISION (TREE_TYPE (val))
1925                    < TYPE_PRECISION (double_type_node)))
1926         /* Convert `float' to `double'.  */
1927         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1928       else
1929         /* Convert `short' and `char' to full-size `int'.  */
1930         result = tree_cons (NULL_TREE, default_conversion (val), result);
1931
1932       if (typetail)
1933         typetail = TREE_CHAIN (typetail);
1934     }
1935
1936   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1937     {
1938       if (name)
1939         error ("too few arguments to function `%s'",
1940                IDENTIFIER_POINTER (name));
1941       else
1942         error ("too few arguments to function");
1943     }
1944
1945   return nreverse (result);
1946 }
1947 \f
1948 /* This is the entry point used by the parser
1949    for binary operators in the input.
1950    In addition to constructing the expression,
1951    we check for operands that were written with other binary operators
1952    in a way that is likely to confuse the user.  */
1953
1954 tree
1955 parser_build_binary_op (enum tree_code code, tree arg1, tree arg2)
1956 {
1957   tree result = build_binary_op (code, arg1, arg2, 1);
1958
1959   char class;
1960   char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1961   char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1962   enum tree_code code1 = ERROR_MARK;
1963   enum tree_code code2 = ERROR_MARK;
1964
1965   if (TREE_CODE (result) == ERROR_MARK)
1966     return error_mark_node;
1967
1968   if (IS_EXPR_CODE_CLASS (class1))
1969     code1 = C_EXP_ORIGINAL_CODE (arg1);
1970   if (IS_EXPR_CODE_CLASS (class2))
1971     code2 = C_EXP_ORIGINAL_CODE (arg2);
1972
1973   /* Check for cases such as x+y<<z which users are likely
1974      to misinterpret.  If parens are used, C_EXP_ORIGINAL_CODE
1975      is cleared to prevent these warnings.  */
1976   if (warn_parentheses)
1977     {
1978       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1979         {
1980           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1981               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1982             warning ("suggest parentheses around + or - inside shift");
1983         }
1984
1985       if (code == TRUTH_ORIF_EXPR)
1986         {
1987           if (code1 == TRUTH_ANDIF_EXPR
1988               || code2 == TRUTH_ANDIF_EXPR)
1989             warning ("suggest parentheses around && within ||");
1990         }
1991
1992       if (code == BIT_IOR_EXPR)
1993         {
1994           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1995               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1996               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1997               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1998             warning ("suggest parentheses around arithmetic in operand of |");
1999           /* Check cases like x|y==z */
2000           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2001             warning ("suggest parentheses around comparison in operand of |");
2002         }
2003
2004       if (code == BIT_XOR_EXPR)
2005         {
2006           if (code1 == BIT_AND_EXPR
2007               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2008               || code2 == BIT_AND_EXPR
2009               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2010             warning ("suggest parentheses around arithmetic in operand of ^");
2011           /* Check cases like x^y==z */
2012           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2013             warning ("suggest parentheses around comparison in operand of ^");
2014         }
2015
2016       if (code == BIT_AND_EXPR)
2017         {
2018           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2019               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2020             warning ("suggest parentheses around + or - in operand of &");
2021           /* Check cases like x&y==z */
2022           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2023             warning ("suggest parentheses around comparison in operand of &");
2024         }
2025     }
2026
2027   /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
2028   if (TREE_CODE_CLASS (code) == '<' && extra_warnings
2029       && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
2030     warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2031
2032   unsigned_conversion_warning (result, arg1);
2033   unsigned_conversion_warning (result, arg2);
2034   overflow_warning (result);
2035
2036   class = TREE_CODE_CLASS (TREE_CODE (result));
2037
2038   /* Record the code that was specified in the source,
2039      for the sake of warnings about confusing nesting.  */
2040   if (IS_EXPR_CODE_CLASS (class))
2041     C_SET_EXP_ORIGINAL_CODE (result, code);
2042   else
2043     {
2044       int flag = TREE_CONSTANT (result);
2045       /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
2046          so that convert_for_assignment wouldn't strip it.
2047          That way, we got warnings for things like p = (1 - 1).
2048          But it turns out we should not get those warnings.  */
2049       result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
2050       C_SET_EXP_ORIGINAL_CODE (result, code);
2051       TREE_CONSTANT (result) = flag;
2052     }
2053
2054   return result;
2055 }
2056 \f
2057
2058 /* Return true if `t' is known to be non-negative.  */
2059
2060 int
2061 c_tree_expr_nonnegative_p (tree t)
2062 {
2063   if (TREE_CODE (t) == STMT_EXPR)
2064     {
2065       t = COMPOUND_BODY (STMT_EXPR_STMT (t));
2066
2067       /* Find the last statement in the chain, ignoring the final
2068              * scope statement */
2069       while (TREE_CHAIN (t) != NULL_TREE
2070              && TREE_CODE (TREE_CHAIN (t)) != SCOPE_STMT)
2071         t = TREE_CHAIN (t);
2072       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
2073     }
2074   return tree_expr_nonnegative_p (t);
2075 }
2076
2077 /* Return a tree for the difference of pointers OP0 and OP1.
2078    The resulting tree has type int.  */
2079
2080 static tree
2081 pointer_diff (tree op0, tree op1)
2082 {
2083   tree result, folded;
2084   tree restype = ptrdiff_type_node;
2085
2086   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2087   tree con0, con1, lit0, lit1;
2088   tree orig_op1 = op1;
2089
2090   if (pedantic || warn_pointer_arith)
2091     {
2092       if (TREE_CODE (target_type) == VOID_TYPE)
2093         pedwarn ("pointer of type `void *' used in subtraction");
2094       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2095         pedwarn ("pointer to a function used in subtraction");
2096     }
2097
2098   /* If the conversion to ptrdiff_type does anything like widening or
2099      converting a partial to an integral mode, we get a convert_expression
2100      that is in the way to do any simplifications.
2101      (fold-const.c doesn't know that the extra bits won't be needed.
2102      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2103      different mode in place.)
2104      So first try to find a common term here 'by hand'; we want to cover
2105      at least the cases that occur in legal static initializers.  */
2106   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2107   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2108
2109   if (TREE_CODE (con0) == PLUS_EXPR)
2110     {
2111       lit0 = TREE_OPERAND (con0, 1);
2112       con0 = TREE_OPERAND (con0, 0);
2113     }
2114   else
2115     lit0 = integer_zero_node;
2116
2117   if (TREE_CODE (con1) == PLUS_EXPR)
2118     {
2119       lit1 = TREE_OPERAND (con1, 1);
2120       con1 = TREE_OPERAND (con1, 0);
2121     }
2122   else
2123     lit1 = integer_zero_node;
2124
2125   if (operand_equal_p (con0, con1, 0))
2126     {
2127       op0 = lit0;
2128       op1 = lit1;
2129     }
2130
2131
2132   /* First do the subtraction as integers;
2133      then drop through to build the divide operator.
2134      Do not do default conversions on the minus operator
2135      in case restype is a short type.  */
2136
2137   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2138                          convert (restype, op1), 0);
2139   /* This generates an error if op1 is pointer to incomplete type.  */
2140   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2141     error ("arithmetic on pointer to an incomplete type");
2142
2143   /* This generates an error if op0 is pointer to incomplete type.  */
2144   op1 = c_size_in_bytes (target_type);
2145
2146   /* Divide by the size, in easiest possible way.  */
2147
2148   result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2149
2150   folded = fold (result);
2151   if (folded == result)
2152     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2153   return folded;
2154 }
2155 \f
2156 /* Construct and perhaps optimize a tree representation
2157    for a unary operation.  CODE, a tree_code, specifies the operation
2158    and XARG is the operand.
2159    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2160    the default promotions (such as from short to int).
2161    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2162    allows non-lvalues; this is only used to handle conversion of non-lvalue
2163    arrays to pointers in C99.  */
2164
2165 tree
2166 build_unary_op (enum tree_code code, tree xarg, int flag)
2167 {
2168   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2169   tree arg = xarg;
2170   tree argtype = 0;
2171   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2172   tree val;
2173   int noconvert = flag;
2174
2175   if (typecode == ERROR_MARK)
2176     return error_mark_node;
2177   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2178     typecode = INTEGER_TYPE;
2179
2180   switch (code)
2181     {
2182     case CONVERT_EXPR:
2183       /* This is used for unary plus, because a CONVERT_EXPR
2184          is enough to prevent anybody from looking inside for
2185          associativity, but won't generate any code.  */
2186       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2187             || typecode == COMPLEX_TYPE))
2188         {
2189           error ("wrong type argument to unary plus");
2190           return error_mark_node;
2191         }
2192       else if (!noconvert)
2193         arg = default_conversion (arg);
2194       arg = non_lvalue (arg);
2195       break;
2196
2197     case NEGATE_EXPR:
2198       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2199             || typecode == COMPLEX_TYPE
2200             || typecode == VECTOR_TYPE))
2201         {
2202           error ("wrong type argument to unary minus");
2203           return error_mark_node;
2204         }
2205       else if (!noconvert)
2206         arg = default_conversion (arg);
2207       break;
2208
2209     case BIT_NOT_EXPR:
2210       if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2211         {
2212           if (!noconvert)
2213             arg = default_conversion (arg);
2214         }
2215       else if (typecode == COMPLEX_TYPE)
2216         {
2217           code = CONJ_EXPR;
2218           if (pedantic)
2219             pedwarn ("ISO C does not support `~' for complex conjugation");
2220           if (!noconvert)
2221             arg = default_conversion (arg);
2222         }
2223       else
2224         {
2225           error ("wrong type argument to bit-complement");
2226           return error_mark_node;
2227         }
2228       break;
2229
2230     case ABS_EXPR:
2231       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2232         {
2233           error ("wrong type argument to abs");
2234           return error_mark_node;
2235         }
2236       else if (!noconvert)
2237         arg = default_conversion (arg);
2238       break;
2239
2240     case CONJ_EXPR:
2241       /* Conjugating a real value is a no-op, but allow it anyway.  */
2242       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2243             || typecode == COMPLEX_TYPE))
2244         {
2245           error ("wrong type argument to conjugation");
2246           return error_mark_node;
2247         }
2248       else if (!noconvert)
2249         arg = default_conversion (arg);
2250       break;
2251
2252     case TRUTH_NOT_EXPR:
2253       if (typecode != INTEGER_TYPE
2254           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2255           && typecode != COMPLEX_TYPE
2256           /* These will convert to a pointer.  */
2257           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2258         {
2259           error ("wrong type argument to unary exclamation mark");
2260           return error_mark_node;
2261         }
2262       arg = c_common_truthvalue_conversion (arg);
2263       return invert_truthvalue (arg);
2264
2265     case NOP_EXPR:
2266       break;
2267
2268     case REALPART_EXPR:
2269       if (TREE_CODE (arg) == COMPLEX_CST)
2270         return TREE_REALPART (arg);
2271       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2272         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2273       else
2274         return arg;
2275
2276     case IMAGPART_EXPR:
2277       if (TREE_CODE (arg) == COMPLEX_CST)
2278         return TREE_IMAGPART (arg);
2279       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2280         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2281       else
2282         return convert (TREE_TYPE (arg), integer_zero_node);
2283
2284     case PREINCREMENT_EXPR:
2285     case POSTINCREMENT_EXPR:
2286     case PREDECREMENT_EXPR:
2287     case POSTDECREMENT_EXPR:
2288
2289       /* Increment or decrement the real part of the value,
2290          and don't change the imaginary part.  */
2291       if (typecode == COMPLEX_TYPE)
2292         {
2293           tree real, imag;
2294
2295           if (pedantic)
2296             pedwarn ("ISO C does not support `++' and `--' on complex types");
2297
2298           arg = stabilize_reference (arg);
2299           real = build_unary_op (REALPART_EXPR, arg, 1);
2300           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2301           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2302                         build_unary_op (code, real, 1), imag);
2303         }
2304
2305       /* Report invalid types.  */
2306
2307       if (typecode != POINTER_TYPE
2308           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2309         {
2310           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2311             error ("wrong type argument to increment");
2312           else
2313             error ("wrong type argument to decrement");
2314
2315           return error_mark_node;
2316         }
2317
2318       {
2319         tree inc;
2320         tree result_type = TREE_TYPE (arg);
2321
2322         arg = get_unwidened (arg, 0);
2323         argtype = TREE_TYPE (arg);
2324
2325         /* Compute the increment.  */
2326
2327         if (typecode == POINTER_TYPE)
2328           {
2329             /* If pointer target is an undefined struct,
2330                we just cannot know how to do the arithmetic.  */
2331             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2332               {
2333                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2334                   error ("increment of pointer to unknown structure");
2335                 else
2336                   error ("decrement of pointer to unknown structure");
2337               }
2338             else if ((pedantic || warn_pointer_arith)
2339                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2340                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2341               {
2342                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2343                   pedwarn ("wrong type argument to increment");
2344                 else
2345                   pedwarn ("wrong type argument to decrement");
2346               }
2347
2348             inc = c_size_in_bytes (TREE_TYPE (result_type));
2349           }
2350         else
2351           inc = integer_one_node;
2352
2353         inc = convert (argtype, inc);
2354
2355         /* Complain about anything else that is not a true lvalue.  */
2356         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2357                                     || code == POSTINCREMENT_EXPR)
2358                                    ? "invalid lvalue in increment"
2359                                    : "invalid lvalue in decrement")))
2360           return error_mark_node;
2361
2362         /* Report a read-only lvalue.  */
2363         if (TREE_READONLY (arg))
2364           readonly_warning (arg,
2365                             ((code == PREINCREMENT_EXPR
2366                               || code == POSTINCREMENT_EXPR)
2367                              ? "increment" : "decrement"));
2368
2369         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2370           val = boolean_increment (code, arg);
2371         else
2372           val = build (code, TREE_TYPE (arg), arg, inc);
2373         TREE_SIDE_EFFECTS (val) = 1;
2374         val = convert (result_type, val);
2375         if (TREE_CODE (val) != code)
2376           TREE_NO_UNUSED_WARNING (val) = 1;
2377         return val;
2378       }
2379
2380     case ADDR_EXPR:
2381       /* Note that this operation never does default_conversion.  */
2382
2383       /* Let &* cancel out to simplify resulting code.  */
2384       if (TREE_CODE (arg) == INDIRECT_REF)
2385         {
2386           /* Don't let this be an lvalue.  */
2387           if (lvalue_p (TREE_OPERAND (arg, 0)))
2388             return non_lvalue (TREE_OPERAND (arg, 0));
2389           return TREE_OPERAND (arg, 0);
2390         }
2391
2392       /* For &x[y], return x+y */
2393       if (TREE_CODE (arg) == ARRAY_REF)
2394         {
2395           if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2396             return error_mark_node;
2397           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2398                                   TREE_OPERAND (arg, 1), 1);
2399         }
2400
2401       /* Anything not already handled and not a true memory reference
2402          or a non-lvalue array is an error.  */
2403       else if (typecode != FUNCTION_TYPE && !flag
2404                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
2405         return error_mark_node;
2406
2407       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2408       argtype = TREE_TYPE (arg);
2409
2410       /* If the lvalue is const or volatile, merge that into the type
2411          to which the address will point.  Note that you can't get a
2412          restricted pointer by taking the address of something, so we
2413          only have to deal with `const' and `volatile' here.  */
2414       if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
2415           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2416           argtype = c_build_type_variant (argtype,
2417                                           TREE_READONLY (arg),
2418                                           TREE_THIS_VOLATILE (arg));
2419
2420       argtype = build_pointer_type (argtype);
2421
2422       if (!c_mark_addressable (arg))
2423         return error_mark_node;
2424
2425       {
2426         tree addr;
2427
2428         if (TREE_CODE (arg) == COMPONENT_REF)
2429           {
2430             tree field = TREE_OPERAND (arg, 1);
2431
2432             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
2433
2434             if (DECL_C_BIT_FIELD (field))
2435               {
2436                 error ("attempt to take address of bit-field structure member `%s'",
2437                        IDENTIFIER_POINTER (DECL_NAME (field)));
2438                 return error_mark_node;
2439               }
2440
2441             addr = fold (build (PLUS_EXPR, argtype,
2442                                 convert (argtype, addr),
2443                                 convert (argtype, byte_position (field))));
2444           }
2445         else
2446           addr = build1 (code, argtype, arg);
2447
2448         /* Address of a static or external variable or
2449            file-scope function counts as a constant.  */
2450         if (staticp (arg)
2451             && ! (TREE_CODE (arg) == FUNCTION_DECL
2452                   && !DECL_FILE_SCOPE_P (arg)))
2453           TREE_CONSTANT (addr) = 1;
2454         return addr;
2455       }
2456
2457     default:
2458       break;
2459     }
2460
2461   if (argtype == 0)
2462     argtype = TREE_TYPE (arg);
2463   return fold (build1 (code, argtype, arg));
2464 }
2465
2466 /* Return nonzero if REF is an lvalue valid for this language.
2467    Lvalues can be assigned, unless their type has TYPE_READONLY.
2468    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
2469
2470 int
2471 lvalue_p (tree ref)
2472 {
2473   enum tree_code code = TREE_CODE (ref);
2474
2475   switch (code)
2476     {
2477     case REALPART_EXPR:
2478     case IMAGPART_EXPR:
2479     case COMPONENT_REF:
2480       return lvalue_p (TREE_OPERAND (ref, 0));
2481
2482     case COMPOUND_LITERAL_EXPR:
2483     case STRING_CST:
2484       return 1;
2485
2486     case INDIRECT_REF:
2487     case ARRAY_REF:
2488     case VAR_DECL:
2489     case PARM_DECL:
2490     case RESULT_DECL:
2491     case ERROR_MARK:
2492       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2493               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2494
2495     case BIND_EXPR:
2496     case RTL_EXPR:
2497       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2498
2499     default:
2500       return 0;
2501     }
2502 }
2503
2504 /* Return nonzero if REF is an lvalue valid for this language;
2505    otherwise, print an error message and return zero.  */
2506
2507 int
2508 lvalue_or_else (tree ref, const char *msgid)
2509 {
2510   int win = lvalue_p (ref);
2511
2512   if (! win)
2513     error ("%s", msgid);
2514
2515   return win;
2516 }
2517
2518 \f
2519 /* Warn about storing in something that is `const'.  */
2520
2521 void
2522 readonly_warning (tree arg, const char *msgid)
2523 {
2524   if (TREE_CODE (arg) == COMPONENT_REF)
2525     {
2526       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2527         readonly_warning (TREE_OPERAND (arg, 0), msgid);
2528       else
2529         pedwarn ("%s of read-only member `%s'", _(msgid),
2530                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2531     }
2532   else if (TREE_CODE (arg) == VAR_DECL)
2533     pedwarn ("%s of read-only variable `%s'", _(msgid),
2534              IDENTIFIER_POINTER (DECL_NAME (arg)));
2535   else
2536     pedwarn ("%s of read-only location", _(msgid));
2537 }
2538 \f
2539 /* Mark EXP saying that we need to be able to take the
2540    address of it; it should not be allocated in a register.
2541    Returns true if successful.  */
2542
2543 bool
2544 c_mark_addressable (tree exp)
2545 {
2546   tree x = exp;
2547
2548   while (1)
2549     switch (TREE_CODE (x))
2550       {
2551       case COMPONENT_REF:
2552         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2553           {
2554             error ("cannot take address of bit-field `%s'",
2555                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
2556             return false;
2557           }
2558
2559         /* ... fall through ...  */
2560
2561       case ADDR_EXPR:
2562       case ARRAY_REF:
2563       case REALPART_EXPR:
2564       case IMAGPART_EXPR:
2565         x = TREE_OPERAND (x, 0);
2566         break;
2567
2568       case COMPOUND_LITERAL_EXPR:
2569       case CONSTRUCTOR:
2570         TREE_ADDRESSABLE (x) = 1;
2571         return true;
2572
2573       case VAR_DECL:
2574       case CONST_DECL:
2575       case PARM_DECL:
2576       case RESULT_DECL:
2577         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
2578             && DECL_NONLOCAL (x))
2579           {
2580             if (TREE_PUBLIC (x))
2581               {
2582                 error ("global register variable `%s' used in nested function",
2583                        IDENTIFIER_POINTER (DECL_NAME (x)));
2584                 return false;
2585               }
2586             pedwarn ("register variable `%s' used in nested function",
2587                      IDENTIFIER_POINTER (DECL_NAME (x)));
2588           }
2589         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
2590           {
2591             if (TREE_PUBLIC (x))
2592               {
2593                 error ("address of global register variable `%s' requested",
2594                        IDENTIFIER_POINTER (DECL_NAME (x)));
2595                 return false;
2596               }
2597
2598             /* If we are making this addressable due to its having
2599                volatile components, give a different error message.  Also
2600                handle the case of an unnamed parameter by not trying
2601                to give the name.  */
2602
2603             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
2604               {
2605                 error ("cannot put object with volatile field into register");
2606                 return false;
2607               }
2608
2609             pedwarn ("address of register variable `%s' requested",
2610                      IDENTIFIER_POINTER (DECL_NAME (x)));
2611           }
2612         put_var_into_stack (x, /*rescan=*/true);
2613
2614         /* drops in */
2615       case FUNCTION_DECL:
2616         TREE_ADDRESSABLE (x) = 1;
2617         /* drops out */
2618       default:
2619         return true;
2620     }
2621 }
2622 \f
2623 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
2624
2625 tree
2626 build_conditional_expr (tree ifexp, tree op1, tree op2)
2627 {
2628   tree type1;
2629   tree type2;
2630   enum tree_code code1;
2631   enum tree_code code2;
2632   tree result_type = NULL;
2633   tree orig_op1 = op1, orig_op2 = op2;
2634
2635   ifexp = c_common_truthvalue_conversion (default_conversion (ifexp));
2636
2637   /* Promote both alternatives.  */
2638
2639   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2640     op1 = default_conversion (op1);
2641   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2642     op2 = default_conversion (op2);
2643
2644   if (TREE_CODE (ifexp) == ERROR_MARK
2645       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2646       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2647     return error_mark_node;
2648
2649   type1 = TREE_TYPE (op1);
2650   code1 = TREE_CODE (type1);
2651   type2 = TREE_TYPE (op2);
2652   code2 = TREE_CODE (type2);
2653
2654   /* C90 does not permit non-lvalue arrays in conditional expressions.
2655      In C99 they will be pointers by now.  */
2656   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2657     {
2658       error ("non-lvalue array in conditional expression");
2659       return error_mark_node;
2660     }
2661
2662   /* Quickly detect the usual case where op1 and op2 have the same type
2663      after promotion.  */
2664   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2665     {
2666       if (type1 == type2)
2667         result_type = type1;
2668       else
2669         result_type = TYPE_MAIN_VARIANT (type1);
2670     }
2671   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2672             || code1 == COMPLEX_TYPE)
2673            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2674                || code2 == COMPLEX_TYPE))
2675     {
2676       result_type = common_type (type1, type2);
2677
2678       /* If -Wsign-compare, warn here if type1 and type2 have
2679          different signedness.  We'll promote the signed to unsigned
2680          and later code won't know it used to be different.
2681          Do this check on the original types, so that explicit casts
2682          will be considered, but default promotions won't.  */
2683       if (warn_sign_compare && !skip_evaluation)
2684         {
2685           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
2686           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
2687
2688           if (unsigned_op1 ^ unsigned_op2)
2689             {
2690               /* Do not warn if the result type is signed, since the
2691                  signed type will only be chosen if it can represent
2692                  all the values of the unsigned type.  */
2693               if (! TREE_UNSIGNED (result_type))
2694                 /* OK */;
2695               /* Do not warn if the signed quantity is an unsuffixed
2696                  integer literal (or some static constant expression
2697                  involving such literals) and it is non-negative.  */
2698               else if ((unsigned_op2 && c_tree_expr_nonnegative_p (op1))
2699                        || (unsigned_op1 && c_tree_expr_nonnegative_p (op2)))
2700                 /* OK */;
2701               else
2702                 warning ("signed and unsigned type in conditional expression");
2703             }
2704         }
2705     }
2706   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2707     {
2708       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2709         pedwarn ("ISO C forbids conditional expr with only one void side");
2710       result_type = void_type_node;
2711     }
2712   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2713     {
2714       if (comp_target_types (type1, type2, 1))
2715         result_type = common_type (type1, type2);
2716       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2717                && TREE_CODE (orig_op1) != NOP_EXPR)
2718         result_type = qualify_type (type2, type1);
2719       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2720                && TREE_CODE (orig_op2) != NOP_EXPR)
2721         result_type = qualify_type (type1, type2);
2722       else if (VOID_TYPE_P (TREE_TYPE (type1)))
2723         {
2724           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2725             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2726           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2727                                                           TREE_TYPE (type2)));
2728         }
2729       else if (VOID_TYPE_P (TREE_TYPE (type2)))
2730         {
2731           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2732             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2733           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2734                                                           TREE_TYPE (type1)));
2735         }
2736       else
2737         {
2738           pedwarn ("pointer type mismatch in conditional expression");
2739           result_type = build_pointer_type (void_type_node);
2740         }
2741     }
2742   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2743     {
2744       if (! integer_zerop (op2))
2745         pedwarn ("pointer/integer type mismatch in conditional expression");
2746       else
2747         {
2748           op2 = null_pointer_node;
2749         }
2750       result_type = type1;
2751     }
2752   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2753     {
2754       if (!integer_zerop (op1))
2755         pedwarn ("pointer/integer type mismatch in conditional expression");
2756       else
2757         {
2758           op1 = null_pointer_node;
2759         }
2760       result_type = type2;
2761     }
2762
2763   if (!result_type)
2764     {
2765       if (flag_cond_mismatch)
2766         result_type = void_type_node;
2767       else
2768         {
2769           error ("type mismatch in conditional expression");
2770           return error_mark_node;
2771         }
2772     }
2773
2774   /* Merge const and volatile flags of the incoming types.  */
2775   result_type
2776     = build_type_variant (result_type,
2777                           TREE_READONLY (op1) || TREE_READONLY (op2),
2778                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
2779
2780   if (result_type != TREE_TYPE (op1))
2781     op1 = convert_and_check (result_type, op1);
2782   if (result_type != TREE_TYPE (op2))
2783     op2 = convert_and_check (result_type, op2);
2784
2785   if (TREE_CODE (ifexp) == INTEGER_CST)
2786     return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
2787
2788   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
2789 }
2790 \f
2791 /* Given a list of expressions, return a compound expression
2792    that performs them all and returns the value of the last of them.  */
2793
2794 tree
2795 build_compound_expr (tree list)
2796 {
2797   return internal_build_compound_expr (list, TRUE);
2798 }
2799
2800 static tree
2801 internal_build_compound_expr (tree list, int first_p)
2802 {
2803   tree rest;
2804
2805   if (TREE_CHAIN (list) == 0)
2806     {
2807       /* Convert arrays and functions to pointers when there
2808          really is a comma operator.  */
2809       if (!first_p)
2810         TREE_VALUE (list)
2811           = default_function_array_conversion (TREE_VALUE (list));
2812
2813       /* Don't let (0, 0) be null pointer constant.  */
2814       if (!first_p && integer_zerop (TREE_VALUE (list)))
2815         return non_lvalue (TREE_VALUE (list));
2816       return TREE_VALUE (list);
2817     }
2818
2819   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
2820
2821   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
2822     {
2823       /* The left-hand operand of a comma expression is like an expression
2824          statement: with -Wextra or -Wunused, we should warn if it doesn't have
2825          any side-effects, unless it was explicitly cast to (void).  */
2826       if (warn_unused_value
2827            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
2828                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
2829         warning ("left-hand operand of comma expression has no effect");
2830     }
2831
2832   /* With -Wunused, we should also warn if the left-hand operand does have
2833      side-effects, but computes a value which is not used.  For example, in
2834      `foo() + bar(), baz()' the result of the `+' operator is not used,
2835      so we should issue a warning.  */
2836   else if (warn_unused_value)
2837     warn_if_unused_value (TREE_VALUE (list));
2838
2839   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
2840 }
2841
2842 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
2843
2844 tree
2845 build_c_cast (tree type, tree expr)
2846 {
2847   tree value = expr;
2848
2849   if (type == error_mark_node || expr == error_mark_node)
2850     return error_mark_node;
2851
2852   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
2853      only in <protocol> qualifications.  But when constructing cast expressions,
2854      the protocols do matter and must be kept around.  */
2855   if (!c_dialect_objc () || !objc_is_object_ptr (type))
2856     type = TYPE_MAIN_VARIANT (type);
2857
2858   if (TREE_CODE (type) == ARRAY_TYPE)
2859     {
2860       error ("cast specifies array type");
2861       return error_mark_node;
2862     }
2863
2864   if (TREE_CODE (type) == FUNCTION_TYPE)
2865     {
2866       error ("cast specifies function type");
2867       return error_mark_node;
2868     }
2869
2870   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
2871     {
2872       if (pedantic)
2873         {
2874           if (TREE_CODE (type) == RECORD_TYPE
2875               || TREE_CODE (type) == UNION_TYPE)
2876             pedwarn ("ISO C forbids casting nonscalar to the same type");
2877         }
2878     }
2879   else if (TREE_CODE (type) == UNION_TYPE)
2880     {
2881       tree field;
2882       value = default_function_array_conversion (value);
2883
2884       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2885         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
2886                        TYPE_MAIN_VARIANT (TREE_TYPE (value)), COMPARE_STRICT))
2887           break;
2888
2889       if (field)
2890         {
2891           tree t;
2892
2893           if (pedantic)
2894             pedwarn ("ISO C forbids casts to union type");
2895           t = digest_init (type,
2896                            build_constructor (type,
2897                                               build_tree_list (field, value)),
2898                            0);
2899           TREE_CONSTANT (t) = TREE_CONSTANT (value);
2900           return t;
2901         }
2902       error ("cast to union type from type not present in union");
2903       return error_mark_node;
2904     }
2905   else
2906     {
2907       tree otype, ovalue;
2908
2909       /* If casting to void, avoid the error that would come
2910          from default_conversion in the case of a non-lvalue array.  */
2911       if (type == void_type_node)
2912         return build1 (CONVERT_EXPR, type, value);
2913
2914       /* Convert functions and arrays to pointers,
2915          but don't convert any other types.  */
2916       value = default_function_array_conversion (value);
2917       otype = TREE_TYPE (value);
2918
2919       /* Optionally warn about potentially worrisome casts.  */
2920
2921       if (warn_cast_qual
2922           && TREE_CODE (type) == POINTER_TYPE
2923           && TREE_CODE (otype) == POINTER_TYPE)
2924         {
2925           tree in_type = type;
2926           tree in_otype = otype;
2927           int added = 0;
2928           int discarded = 0;
2929
2930           /* Check that the qualifiers on IN_TYPE are a superset of
2931              the qualifiers of IN_OTYPE.  The outermost level of
2932              POINTER_TYPE nodes is uninteresting and we stop as soon
2933              as we hit a non-POINTER_TYPE node on either type.  */
2934           do
2935             {
2936               in_otype = TREE_TYPE (in_otype);
2937               in_type = TREE_TYPE (in_type);
2938
2939               /* GNU C allows cv-qualified function types.  'const'
2940                  means the function is very pure, 'volatile' means it
2941                  can't return.  We need to warn when such qualifiers
2942                  are added, not when they're taken away.  */
2943               if (TREE_CODE (in_otype) == FUNCTION_TYPE
2944                   && TREE_CODE (in_type) == FUNCTION_TYPE)
2945                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
2946               else
2947                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
2948             }
2949           while (TREE_CODE (in_type) == POINTER_TYPE
2950                  && TREE_CODE (in_otype) == POINTER_TYPE);
2951
2952           if (added)
2953             warning ("cast adds new qualifiers to function type");
2954
2955           if (discarded)
2956             /* There are qualifiers present in IN_OTYPE that are not
2957                present in IN_TYPE.  */
2958             warning ("cast discards qualifiers from pointer target type");
2959         }
2960
2961       /* Warn about possible alignment problems.  */
2962       if (STRICT_ALIGNMENT && warn_cast_align
2963           && TREE_CODE (type) == POINTER_TYPE
2964           && TREE_CODE (otype) == POINTER_TYPE
2965           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
2966           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
2967           /* Don't warn about opaque types, where the actual alignment
2968              restriction is unknown.  */
2969           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
2970                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
2971                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
2972           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
2973         warning ("cast increases required alignment of target type");
2974
2975       if (TREE_CODE (type) == INTEGER_TYPE
2976           && TREE_CODE (otype) == POINTER_TYPE
2977           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
2978           && !TREE_CONSTANT (value))
2979         warning ("cast from pointer to integer of different size");
2980
2981       if (warn_bad_function_cast
2982           && TREE_CODE (value) == CALL_EXPR
2983           && TREE_CODE (type) != TREE_CODE (otype))
2984         warning ("cast does not match function type");
2985
2986       if (TREE_CODE (type) == POINTER_TYPE
2987           && TREE_CODE (otype) == INTEGER_TYPE
2988           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
2989           /* Don't warn about converting any constant.  */
2990           && !TREE_CONSTANT (value))
2991         warning ("cast to pointer from integer of different size");
2992
2993       if (TREE_CODE (type) == POINTER_TYPE
2994           && TREE_CODE (otype) == POINTER_TYPE
2995           && TREE_CODE (expr) == ADDR_EXPR
2996           && DECL_P (TREE_OPERAND (expr, 0))
2997           && flag_strict_aliasing && warn_strict_aliasing
2998           && !VOID_TYPE_P (TREE_TYPE (type)))
2999         {
3000           /* Casting the address of a decl to non void pointer. Warn
3001              if the cast breaks type based aliasing.  */
3002           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3003             warning ("type-punning to incomplete type might break strict-aliasing rules");
3004           else if (!alias_sets_conflict_p
3005                    (get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0))),
3006                     get_alias_set (TREE_TYPE (type))))
3007             warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3008         }
3009
3010       /* If pedantic, warn for conversions between function and object
3011          pointer types, except for converting a null pointer constant
3012          to function pointer type.  */
3013       if (pedantic
3014           && TREE_CODE (type) == POINTER_TYPE
3015           && TREE_CODE (otype) == POINTER_TYPE
3016           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3017           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3018         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3019
3020       if (pedantic
3021           && TREE_CODE (type) == POINTER_TYPE
3022           && TREE_CODE (otype) == POINTER_TYPE
3023           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3024           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3025           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3026                && TREE_CODE (expr) != NOP_EXPR))
3027         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3028
3029       ovalue = value;
3030       /* Replace a nonvolatile const static variable with its value.  */
3031       if (optimize && TREE_CODE (value) == VAR_DECL)
3032         value = decl_constant_value (value);
3033       value = convert (type, value);
3034
3035       /* Ignore any integer overflow caused by the cast.  */
3036       if (TREE_CODE (value) == INTEGER_CST)
3037         {
3038           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3039           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3040         }
3041     }
3042
3043   /* Don't let (void *) (FOO *) 0 be a null pointer constant.  */
3044   if (TREE_CODE (value) == INTEGER_CST
3045       && TREE_CODE (expr) == INTEGER_CST
3046       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3047     value = non_lvalue (value);
3048
3049   /* Don't let a cast be an lvalue.  */
3050   if (value == expr)
3051     value = non_lvalue (value);
3052
3053   return value;
3054 }
3055
3056 /* Interpret a cast of expression EXPR to type TYPE.  */
3057 tree
3058 c_cast_expr (tree type, tree expr)
3059 {
3060   int saved_wsp = warn_strict_prototypes;
3061
3062   /* This avoids warnings about unprototyped casts on
3063      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3064   if (TREE_CODE (expr) == INTEGER_CST)
3065     warn_strict_prototypes = 0;
3066   type = groktypename (type);
3067   warn_strict_prototypes = saved_wsp;
3068
3069   return build_c_cast (type, expr);
3070 }
3071
3072 \f
3073 /* Build an assignment expression of lvalue LHS from value RHS.
3074    MODIFYCODE is the code for a binary operator that we use
3075    to combine the old value of LHS with RHS to get the new value.
3076    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3077
3078 tree
3079 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3080 {
3081   tree result;
3082   tree newrhs;
3083   tree lhstype = TREE_TYPE (lhs);
3084   tree olhstype = lhstype;
3085
3086   /* Types that aren't fully specified cannot be used in assignments.  */
3087   lhs = require_complete_type (lhs);
3088
3089   /* Avoid duplicate error messages from operands that had errors.  */
3090   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3091     return error_mark_node;
3092
3093   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3094   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3095      whose value is 0 to count as a null pointer constant.  */
3096   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3097     rhs = TREE_OPERAND (rhs, 0);
3098
3099   newrhs = rhs;
3100
3101   /* If a binary op has been requested, combine the old LHS value with the RHS
3102      producing the value we should actually store into the LHS.  */
3103
3104   if (modifycode != NOP_EXPR)
3105     {
3106       lhs = stabilize_reference (lhs);
3107       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3108     }
3109
3110   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3111     return error_mark_node;
3112
3113   /* Warn about storing in something that is `const'.  */
3114
3115   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3116       || ((TREE_CODE (lhstype) == RECORD_TYPE
3117            || TREE_CODE (lhstype) == UNION_TYPE)
3118           && C_TYPE_FIELDS_READONLY (lhstype)))
3119     readonly_warning (lhs, "assignment");
3120
3121   /* If storing into a structure or union member,
3122      it has probably been given type `int'.
3123      Compute the type that would go with
3124      the actual amount of storage the member occupies.  */
3125
3126   if (TREE_CODE (lhs) == COMPONENT_REF
3127       && (TREE_CODE (lhstype) == INTEGER_TYPE
3128           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3129           || TREE_CODE (lhstype) == REAL_TYPE
3130           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3131     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3132
3133   /* If storing in a field that is in actuality a short or narrower than one,
3134      we must store in the field in its actual type.  */
3135
3136   if (lhstype != TREE_TYPE (lhs))
3137     {
3138       lhs = copy_node (lhs);
3139       TREE_TYPE (lhs) = lhstype;
3140     }
3141
3142   /* Convert new value to destination type.  */
3143
3144   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3145                                    NULL_TREE, NULL_TREE, 0);
3146   if (TREE_CODE (newrhs) == ERROR_MARK)
3147     return error_mark_node;
3148
3149   /* Scan operands */
3150
3151   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3152   TREE_SIDE_EFFECTS (result) = 1;
3153
3154   /* If we got the LHS in a different type for storing in,
3155      convert the result back to the nominal type of LHS
3156      so that the value we return always has the same type
3157      as the LHS argument.  */
3158
3159   if (olhstype == TREE_TYPE (result))
3160     return result;
3161   return convert_for_assignment (olhstype, result, _("assignment"),
3162                                  NULL_TREE, NULL_TREE, 0);
3163 }
3164 \f
3165 /* Convert value RHS to type TYPE as preparation for an assignment
3166    to an lvalue of type TYPE.
3167    The real work of conversion is done by `convert'.
3168    The purpose of this function is to generate error messages
3169    for assignments that are not allowed in C.
3170    ERRTYPE is a string to use in error messages:
3171    "assignment", "return", etc.  If it is null, this is parameter passing
3172    for a function call (and different error messages are output).
3173
3174    FUNNAME is the name of the function being called,
3175    as an IDENTIFIER_NODE, or null.
3176    PARMNUM is the number of the argument, for printing in error messages.  */
3177
3178 static tree
3179 convert_for_assignment (tree type, tree rhs, const char *errtype,
3180                         tree fundecl, tree funname, int parmnum)
3181 {
3182   enum tree_code codel = TREE_CODE (type);
3183   tree rhstype;
3184   enum tree_code coder;
3185
3186   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3187   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3188      whose value is 0 to count as a null pointer constant.  */
3189   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3190     rhs = TREE_OPERAND (rhs, 0);
3191
3192   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3193       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3194     rhs = default_conversion (rhs);
3195   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3196     rhs = decl_constant_value_for_broken_optimization (rhs);
3197
3198   rhstype = TREE_TYPE (rhs);
3199   coder = TREE_CODE (rhstype);
3200
3201   if (coder == ERROR_MARK)
3202     return error_mark_node;
3203
3204   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3205     {
3206       overflow_warning (rhs);
3207       /* Check for Objective-C protocols.  This will automatically
3208          issue a warning if there are protocol violations.  No need to
3209          use the return value.  */
3210       if (c_dialect_objc ())
3211         objc_comptypes (type, rhstype, 0);
3212       return rhs;
3213     }
3214
3215   if (coder == VOID_TYPE)
3216     {
3217       error ("void value not ignored as it ought to be");
3218       return error_mark_node;
3219     }
3220   /* A type converts to a reference to it.
3221      This code doesn't fully support references, it's just for the
3222      special case of va_start and va_copy.  */
3223   if (codel == REFERENCE_TYPE
3224       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs), COMPARE_STRICT) == 1)
3225     {
3226       if (!lvalue_p (rhs))
3227         {
3228           error ("cannot pass rvalue to reference parameter");
3229           return error_mark_node;
3230         }
3231       if (!c_mark_addressable (rhs))
3232         return error_mark_node;
3233       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3234
3235       /* We already know that these two types are compatible, but they
3236          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3237          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3238          likely to be va_list, a typedef to __builtin_va_list, which
3239          is different enough that it will cause problems later.  */
3240       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3241         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3242
3243       rhs = build1 (NOP_EXPR, type, rhs);
3244       return rhs;
3245     }
3246   /* Some types can interconvert without explicit casts.  */
3247   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3248            && ((*targetm.vector_opaque_p) (type)
3249                || (*targetm.vector_opaque_p) (rhstype)))
3250     return convert (type, rhs);
3251   /* Arithmetic types all interconvert, and enum is treated like int.  */
3252   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3253             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3254             || codel == BOOLEAN_TYPE)
3255            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3256                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3257                || coder == BOOLEAN_TYPE))
3258     return convert_and_check (type, rhs);
3259
3260   /* Conversion to a transparent union from its member types.
3261      This applies only to function arguments.  */
3262   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
3263     {
3264       tree memb_types;
3265       tree marginal_memb_type = 0;
3266
3267       for (memb_types = TYPE_FIELDS (type); memb_types;
3268            memb_types = TREE_CHAIN (memb_types))
3269         {
3270           tree memb_type = TREE_TYPE (memb_types);
3271
3272           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3273                          TYPE_MAIN_VARIANT (rhstype), COMPARE_STRICT))
3274             break;
3275
3276           if (TREE_CODE (memb_type) != POINTER_TYPE)
3277             continue;
3278
3279           if (coder == POINTER_TYPE)
3280             {
3281               tree ttl = TREE_TYPE (memb_type);
3282               tree ttr = TREE_TYPE (rhstype);
3283
3284               /* Any non-function converts to a [const][volatile] void *
3285                  and vice versa; otherwise, targets must be the same.
3286                  Meanwhile, the lhs target must have all the qualifiers of
3287                  the rhs.  */
3288               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3289                   || comp_target_types (memb_type, rhstype, 0))
3290                 {
3291                   /* If this type won't generate any warnings, use it.  */
3292                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3293                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3294                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3295                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3296                              == TYPE_QUALS (ttr))
3297                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3298                              == TYPE_QUALS (ttl))))
3299                     break;
3300
3301                   /* Keep looking for a better type, but remember this one.  */
3302                   if (! marginal_memb_type)
3303                     marginal_memb_type = memb_type;
3304                 }
3305             }
3306
3307           /* Can convert integer zero to any pointer type.  */
3308           if (integer_zerop (rhs)
3309               || (TREE_CODE (rhs) == NOP_EXPR
3310                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3311             {
3312               rhs = null_pointer_node;
3313               break;
3314             }
3315         }
3316
3317       if (memb_types || marginal_memb_type)
3318         {
3319           if (! memb_types)
3320             {
3321               /* We have only a marginally acceptable member type;
3322                  it needs a warning.  */
3323               tree ttl = TREE_TYPE (marginal_memb_type);
3324               tree ttr = TREE_TYPE (rhstype);
3325
3326               /* Const and volatile mean something different for function
3327                  types, so the usual warnings are not appropriate.  */
3328               if (TREE_CODE (ttr) == FUNCTION_TYPE
3329                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3330                 {
3331                   /* Because const and volatile on functions are
3332                      restrictions that say the function will not do
3333                      certain things, it is okay to use a const or volatile
3334                      function where an ordinary one is wanted, but not
3335                      vice-versa.  */
3336                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3337                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
3338                                          errtype, funname, parmnum);
3339                 }
3340               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3341                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3342                                      errtype, funname,
3343                                      parmnum);
3344             }
3345
3346           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
3347             pedwarn ("ISO C prohibits argument conversion to union type");
3348
3349           return build1 (NOP_EXPR, type, rhs);
3350         }
3351     }
3352
3353   /* Conversions among pointers */
3354   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3355            && (coder == codel))
3356     {
3357       tree ttl = TREE_TYPE (type);
3358       tree ttr = TREE_TYPE (rhstype);
3359       bool is_opaque_pointer;
3360       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3361
3362       /* Opaque pointers are treated like void pointers.  */
3363       is_opaque_pointer = ((*targetm.vector_opaque_p) (type)
3364                            || (*targetm.vector_opaque_p) (rhstype))
3365         && TREE_CODE (ttl) == VECTOR_TYPE
3366         && TREE_CODE (ttr) == VECTOR_TYPE;
3367
3368       /* Any non-function converts to a [const][volatile] void *
3369          and vice versa; otherwise, targets must be the same.
3370          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3371       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3372           || (target_cmp = comp_target_types (type, rhstype, 0))
3373           || is_opaque_pointer
3374           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3375               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3376         {
3377           if (pedantic
3378               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3379                   ||
3380                   (VOID_TYPE_P (ttr)
3381                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3382                       which are not ANSI null ptr constants.  */
3383                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3384                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3385             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
3386                                  errtype, funname, parmnum);
3387           /* Const and volatile mean something different for function types,
3388              so the usual warnings are not appropriate.  */
3389           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3390                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3391             {
3392               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3393                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3394                                      errtype, funname, parmnum);
3395               /* If this is not a case of ignoring a mismatch in signedness,
3396                  no warning.  */
3397               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3398                        || target_cmp)
3399                 ;
3400               /* If there is a mismatch, do warn.  */
3401               else if (pedantic)
3402                 warn_for_assignment ("pointer targets in %s differ in signedness",
3403                                      errtype, funname, parmnum);
3404             }
3405           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3406                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3407             {
3408               /* Because const and volatile on functions are restrictions
3409                  that say the function will not do certain things,
3410                  it is okay to use a const or volatile function
3411                  where an ordinary one is wanted, but not vice-versa.  */
3412               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3413                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3414                                      errtype, funname, parmnum);
3415             }
3416         }
3417       else
3418         warn_for_assignment ("%s from incompatible pointer type",
3419                              errtype, funname, parmnum);
3420       return convert (type, rhs);
3421     }
3422   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3423     {
3424       error ("invalid use of non-lvalue array");
3425       return error_mark_node;
3426     }
3427   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3428     {
3429       /* An explicit constant 0 can convert to a pointer,
3430          or one that results from arithmetic, even including
3431          a cast to integer type.  */
3432       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3433           &&
3434           ! (TREE_CODE (rhs) == NOP_EXPR
3435              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3436              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3437              && integer_zerop (TREE_OPERAND (rhs, 0))))
3438           warn_for_assignment ("%s makes pointer from integer without a cast",
3439                                errtype, funname, parmnum);
3440
3441       return convert (type, rhs);
3442     }
3443   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3444     {
3445       warn_for_assignment ("%s makes integer from pointer without a cast",
3446                            errtype, funname, parmnum);
3447       return convert (type, rhs);
3448     }
3449   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3450     return convert (type, rhs);
3451
3452   if (!errtype)
3453     {
3454       if (funname)
3455         {
3456           tree selector = objc_message_selector ();
3457
3458           if (selector && parmnum > 2)
3459             error ("incompatible type for argument %d of `%s'",
3460                    parmnum - 2, IDENTIFIER_POINTER (selector));
3461           else
3462             error ("incompatible type for argument %d of `%s'",
3463                    parmnum, IDENTIFIER_POINTER (funname));
3464         }
3465       else
3466         error ("incompatible type for argument %d of indirect function call",
3467                parmnum);
3468     }
3469   else
3470     error ("incompatible types in %s", errtype);
3471
3472   return error_mark_node;
3473 }
3474
3475 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3476    is used for error and waring reporting and indicates which argument
3477    is being processed.  */
3478
3479 tree
3480 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3481 {
3482   tree ret, type;
3483
3484   /* If FN was prototyped, the value has been converted already
3485      in convert_arguments.  */
3486   if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3487     return value;
3488
3489   type = TREE_TYPE (parm);
3490   ret = convert_for_assignment (type, value,
3491                                 (char *) 0 /* arg passing  */, fn,
3492                                 DECL_NAME (fn), argnum);
3493   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3494       && INTEGRAL_TYPE_P (type)
3495       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3496     ret = default_conversion (ret);
3497   return ret;
3498 }
3499
3500 /* Print a warning using MSGID.
3501    It gets OPNAME as its one parameter.
3502    if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
3503    Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
3504    FUNCTION and ARGNUM are handled specially if we are building an
3505    Objective-C selector.  */
3506
3507 static void
3508 warn_for_assignment (const char *msgid, const char *opname, tree function,
3509                      int argnum)
3510 {
3511   if (opname == 0)
3512     {
3513       tree selector = objc_message_selector ();
3514       char * new_opname;
3515
3516       if (selector && argnum > 2)
3517         {
3518           function = selector;
3519           argnum -= 2;
3520         }
3521       if (argnum == 0)
3522         {
3523           if (function)
3524             {
3525               /* Function name is known; supply it.  */
3526               const char *const argstring = _("passing arg of `%s'");
3527               new_opname = alloca (IDENTIFIER_LENGTH (function)
3528                                    + strlen (argstring) + 1 + 1);
3529               sprintf (new_opname, argstring,
3530                        IDENTIFIER_POINTER (function));
3531             }
3532           else
3533             {
3534               /* Function name unknown (call through ptr).  */
3535               const char *const argnofun = _("passing arg of pointer to function");
3536               new_opname = alloca (strlen (argnofun) + 1 + 1);
3537               sprintf (new_opname, argnofun);
3538             }
3539         }
3540       else if (function)
3541         {
3542           /* Function name is known; supply it.  */
3543           const char *const argstring = _("passing arg %d of `%s'");
3544           new_opname = alloca (IDENTIFIER_LENGTH (function)
3545                                + strlen (argstring) + 1 + 25 /*%d*/ + 1);
3546           sprintf (new_opname, argstring, argnum,
3547                    IDENTIFIER_POINTER (function));
3548         }
3549       else
3550         {
3551           /* Function name unknown (call through ptr); just give arg number.  */
3552           const char *const argnofun = _("passing arg %d of pointer to function");
3553           new_opname = alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
3554           sprintf (new_opname, argnofun, argnum);
3555         }
3556       opname = new_opname;
3557     }
3558   pedwarn (msgid, opname);
3559 }
3560 \f
3561 /* If VALUE is a compound expr all of whose expressions are constant, then
3562    return its value.  Otherwise, return error_mark_node.
3563
3564    This is for handling COMPOUND_EXPRs as initializer elements
3565    which is allowed with a warning when -pedantic is specified.  */
3566
3567 static tree
3568 valid_compound_expr_initializer (tree value, tree endtype)
3569 {
3570   if (TREE_CODE (value) == COMPOUND_EXPR)
3571     {
3572       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3573           == error_mark_node)
3574         return error_mark_node;
3575       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3576                                               endtype);
3577     }
3578   else if (! TREE_CONSTANT (value)
3579            && ! initializer_constant_valid_p (value, endtype))
3580     return error_mark_node;
3581   else
3582     return value;
3583 }
3584 \f
3585 /* Perform appropriate conversions on the initial value of a variable,
3586    store it in the declaration DECL,
3587    and print any error messages that are appropriate.
3588    If the init is invalid, store an ERROR_MARK.  */
3589
3590 void
3591 store_init_value (tree decl, tree init)
3592 {
3593   tree value, type;
3594
3595   /* If variable's type was invalidly declared, just ignore it.  */
3596
3597   type = TREE_TYPE (decl);
3598   if (TREE_CODE (type) == ERROR_MARK)
3599     return;
3600
3601   /* Digest the specified initializer into an expression.  */
3602
3603   value = digest_init (type, init, TREE_STATIC (decl));
3604
3605   /* Store the expression if valid; else report error.  */
3606
3607   if (warn_traditional && !in_system_header
3608       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
3609     warning ("traditional C rejects automatic aggregate initialization");
3610
3611   DECL_INITIAL (decl) = value;
3612
3613   /* ANSI wants warnings about out-of-range constant initializers.  */
3614   STRIP_TYPE_NOPS (value);
3615   constant_expression_warning (value);
3616
3617   /* Check if we need to set array size from compound literal size.  */
3618   if (TREE_CODE (type) == ARRAY_TYPE
3619       && TYPE_DOMAIN (type) == 0
3620       && value != error_mark_node)
3621     {
3622       tree inside_init = init;
3623
3624       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3625         inside_init = TREE_OPERAND (init, 0);
3626       inside_init = fold (inside_init);
3627
3628       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3629         {
3630           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3631
3632           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3633             {
3634               /* For int foo[] = (int [3]){1}; we need to set array size
3635                  now since later on array initializer will be just the
3636                  brace enclosed list of the compound literal.  */
3637               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3638               layout_type (type);
3639               layout_decl (decl, 0);
3640             }
3641         }
3642     }
3643 }
3644 \f
3645 /* Methods for storing and printing names for error messages.  */
3646
3647 /* Implement a spelling stack that allows components of a name to be pushed
3648    and popped.  Each element on the stack is this structure.  */
3649
3650 struct spelling
3651 {
3652   int kind;
3653   union
3654     {
3655       int i;
3656       const char *s;
3657     } u;
3658 };
3659
3660 #define SPELLING_STRING 1
3661 #define SPELLING_MEMBER 2
3662 #define SPELLING_BOUNDS 3
3663
3664 static struct spelling *spelling;       /* Next stack element (unused).  */
3665 static struct spelling *spelling_base;  /* Spelling stack base.  */
3666 static int spelling_size;               /* Size of the spelling stack.  */
3667
3668 /* Macros to save and restore the spelling stack around push_... functions.
3669    Alternative to SAVE_SPELLING_STACK.  */
3670
3671 #define SPELLING_DEPTH() (spelling - spelling_base)
3672 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3673
3674 /* Push an element on the spelling stack with type KIND and assign VALUE
3675    to MEMBER.  */
3676
3677 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3678 {                                                                       \
3679   int depth = SPELLING_DEPTH ();                                        \
3680                                                                         \
3681   if (depth >= spelling_size)                                           \
3682     {                                                                   \
3683       spelling_size += 10;                                              \
3684       if (spelling_base == 0)                                           \
3685         spelling_base = xmalloc (spelling_size * sizeof (struct spelling)); \
3686       else                                                              \
3687         spelling_base = xrealloc (spelling_base,                \
3688                                   spelling_size * sizeof (struct spelling)); \
3689       RESTORE_SPELLING_DEPTH (depth);                                   \
3690     }                                                                   \
3691                                                                         \
3692   spelling->kind = (KIND);                                              \
3693   spelling->MEMBER = (VALUE);                                           \
3694   spelling++;                                                           \
3695 }
3696
3697 /* Push STRING on the stack.  Printed literally.  */
3698
3699 static void
3700 push_string (const char *string)
3701 {
3702   PUSH_SPELLING (SPELLING_STRING, string, u.s);
3703 }
3704
3705 /* Push a member name on the stack.  Printed as '.' STRING.  */
3706
3707 static void
3708 push_member_name (tree decl)
3709 {
3710   const char *const string
3711     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3712   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3713 }
3714
3715 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
3716
3717 static void
3718 push_array_bounds (int bounds)
3719 {
3720   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3721 }
3722
3723 /* Compute the maximum size in bytes of the printed spelling.  */
3724
3725 static int
3726 spelling_length (void)
3727 {
3728   int size = 0;
3729   struct spelling *p;
3730
3731   for (p = spelling_base; p < spelling; p++)
3732     {
3733       if (p->kind == SPELLING_BOUNDS)
3734         size += 25;
3735       else
3736         size += strlen (p->u.s) + 1;
3737     }
3738
3739   return size;
3740 }
3741
3742 /* Print the spelling to BUFFER and return it.  */
3743
3744 static char *
3745 print_spelling (char *buffer)
3746 {
3747   char *d = buffer;
3748   struct spelling *p;
3749
3750   for (p = spelling_base; p < spelling; p++)
3751     if (p->kind == SPELLING_BOUNDS)
3752       {
3753         sprintf (d, "[%d]", p->u.i);
3754         d += strlen (d);
3755       }
3756     else
3757       {
3758         const char *s;
3759         if (p->kind == SPELLING_MEMBER)
3760           *d++ = '.';
3761         for (s = p->u.s; (*d = *s++); d++)
3762           ;
3763       }
3764   *d++ = '\0';
3765   return buffer;
3766 }
3767
3768 /* Issue an error message for a bad initializer component.
3769    MSGID identifies the message.
3770    The component name is taken from the spelling stack.  */
3771
3772 void
3773 error_init (const char *msgid)
3774 {
3775   char *ofwhat;
3776
3777   error ("%s", _(msgid));
3778   ofwhat = print_spelling (alloca (spelling_length () + 1));
3779   if (*ofwhat)
3780     error ("(near initialization for `%s')", ofwhat);
3781 }
3782
3783 /* Issue a pedantic warning for a bad initializer component.
3784    MSGID identifies the message.
3785    The component name is taken from the spelling stack.  */
3786
3787 void
3788 pedwarn_init (const char *msgid)
3789 {
3790   char *ofwhat;
3791
3792   pedwarn ("%s", _(msgid));
3793   ofwhat = print_spelling (alloca (spelling_length () + 1));
3794   if (*ofwhat)
3795     pedwarn ("(near initialization for `%s')", ofwhat);
3796 }
3797
3798 /* Issue a warning for a bad initializer component.
3799    MSGID identifies the message.
3800    The component name is taken from the spelling stack.  */
3801
3802 static void
3803 warning_init (const char *msgid)
3804 {
3805   char *ofwhat;
3806
3807   warning ("%s", _(msgid));
3808   ofwhat = print_spelling (alloca (spelling_length () + 1));
3809   if (*ofwhat)
3810     warning ("(near initialization for `%s')", ofwhat);
3811 }
3812 \f
3813 /* Digest the parser output INIT as an initializer for type TYPE.
3814    Return a C expression of type TYPE to represent the initial value.
3815
3816    REQUIRE_CONSTANT requests an error if non-constant initializers or
3817    elements are seen.  */
3818
3819 static tree
3820 digest_init (tree type, tree init, int require_constant)
3821 {
3822   enum tree_code code = TREE_CODE (type);
3823   tree inside_init = init;
3824
3825   if (type == error_mark_node
3826       || init == error_mark_node
3827       || TREE_TYPE (init) == error_mark_node)
3828     return error_mark_node;
3829
3830   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3831   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3832      whose value is 0 to count as a null pointer constant.  */
3833   if (TREE_CODE (init) == NON_LVALUE_EXPR)
3834     inside_init = TREE_OPERAND (init, 0);
3835
3836   inside_init = fold (inside_init);
3837
3838   /* Initialization of an array of chars from a string constant
3839      optionally enclosed in braces.  */
3840
3841   if (code == ARRAY_TYPE)
3842     {
3843       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3844       if ((typ1 == char_type_node
3845            || typ1 == signed_char_type_node
3846            || typ1 == unsigned_char_type_node
3847            || typ1 == unsigned_wchar_type_node
3848            || typ1 == signed_wchar_type_node)
3849           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
3850         {
3851           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3852                          TYPE_MAIN_VARIANT (type), COMPARE_STRICT))
3853             return inside_init;
3854
3855           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
3856                != char_type_node)
3857               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
3858             {
3859               error_init ("char-array initialized from wide string");
3860               return error_mark_node;
3861             }
3862           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
3863                == char_type_node)
3864               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
3865             {
3866               error_init ("int-array initialized from non-wide string");
3867               return error_mark_node;
3868             }
3869
3870           TREE_TYPE (inside_init) = type;
3871           if (TYPE_DOMAIN (type) != 0
3872               && TYPE_SIZE (type) != 0
3873               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
3874               /* Subtract 1 (or sizeof (wchar_t))
3875                  because it's ok to ignore the terminating null char
3876                  that is counted in the length of the constant.  */
3877               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
3878                                        TREE_STRING_LENGTH (inside_init)
3879                                        - ((TYPE_PRECISION (typ1)
3880                                            != TYPE_PRECISION (char_type_node))
3881                                           ? (TYPE_PRECISION (wchar_type_node)
3882                                              / BITS_PER_UNIT)
3883                                           : 1)))
3884             pedwarn_init ("initializer-string for array of chars is too long");
3885
3886           return inside_init;
3887         }
3888     }
3889
3890   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
3891      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
3892      below and handle as a constructor.  */
3893     if (code == VECTOR_TYPE
3894         && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT)
3895         && TREE_CONSTANT (inside_init))
3896       {
3897         if (TREE_CODE (inside_init) == VECTOR_CST
3898             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3899                           TYPE_MAIN_VARIANT (type),
3900                           COMPARE_STRICT))
3901           return inside_init;
3902         else
3903           return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
3904       }
3905
3906   /* Any type can be initialized
3907      from an expression of the same type, optionally with braces.  */
3908
3909   if (inside_init && TREE_TYPE (inside_init) != 0
3910       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3911                      TYPE_MAIN_VARIANT (type), COMPARE_STRICT)
3912           || (code == ARRAY_TYPE
3913               && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
3914           || (code == VECTOR_TYPE
3915               && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
3916           || (code == POINTER_TYPE
3917               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
3918               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
3919                             TREE_TYPE (type), COMPARE_STRICT))
3920           || (code == POINTER_TYPE
3921               && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
3922               && comptypes (TREE_TYPE (inside_init),
3923                             TREE_TYPE (type), COMPARE_STRICT))))
3924     {
3925       if (code == POINTER_TYPE)
3926         {
3927           inside_init = default_function_array_conversion (inside_init);
3928
3929           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
3930             {
3931               error_init ("invalid use of non-lvalue array");
3932               return error_mark_node;
3933             }
3934          }
3935
3936       if (code == VECTOR_TYPE)
3937         /* Although the types are compatible, we may require a
3938            conversion.  */
3939         inside_init = convert (type, inside_init);
3940
3941       if (require_constant && !flag_isoc99
3942           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3943         {
3944           /* As an extension, allow initializing objects with static storage
3945              duration with compound literals (which are then treated just as
3946              the brace enclosed list they contain).  */
3947           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3948           inside_init = DECL_INITIAL (decl);
3949         }
3950
3951       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
3952           && TREE_CODE (inside_init) != CONSTRUCTOR)
3953         {
3954           error_init ("array initialized from non-constant array expression");
3955           return error_mark_node;
3956         }
3957
3958       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
3959         inside_init = decl_constant_value_for_broken_optimization (inside_init);
3960
3961       /* Compound expressions can only occur here if -pedantic or
3962          -pedantic-errors is specified.  In the later case, we always want
3963          an error.  In the former case, we simply want a warning.  */
3964       if (require_constant && pedantic
3965           && TREE_CODE (inside_init) == COMPOUND_EXPR)
3966         {
3967           inside_init
3968             = valid_compound_expr_initializer (inside_init,
3969                                                TREE_TYPE (inside_init));
3970           if (inside_init == error_mark_node)
3971             error_init ("initializer element is not constant");
3972           else
3973             pedwarn_init ("initializer element is not constant");
3974           if (flag_pedantic_errors)
3975             inside_init = error_mark_node;
3976         }
3977       else if (require_constant
3978                && (!TREE_CONSTANT (inside_init)
3979                    /* This test catches things like `7 / 0' which
3980                       result in an expression for which TREE_CONSTANT
3981                       is true, but which is not actually something
3982                       that is a legal constant.  We really should not
3983                       be using this function, because it is a part of
3984                       the back-end.  Instead, the expression should
3985                       already have been turned into ERROR_MARK_NODE.  */
3986                    || !initializer_constant_valid_p (inside_init,
3987                                                      TREE_TYPE (inside_init))))
3988         {
3989           error_init ("initializer element is not constant");
3990           inside_init = error_mark_node;
3991         }
3992
3993       return inside_init;
3994     }
3995
3996   /* Handle scalar types, including conversions.  */
3997
3998   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
3999       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4000     {
4001       /* Note that convert_for_assignment calls default_conversion
4002          for arrays and functions.  We must not call it in the
4003          case where inside_init is a null pointer constant.  */
4004       inside_init
4005         = convert_for_assignment (type, init, _("initialization"),
4006                                   NULL_TREE, NULL_TREE, 0);
4007
4008       if (require_constant && ! TREE_CONSTANT (inside_init))
4009         {
4010           error_init ("initializer element is not constant");
4011           inside_init = error_mark_node;
4012         }
4013       else if (require_constant
4014                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4015         {
4016           error_init ("initializer element is not computable at load time");
4017           inside_init = error_mark_node;
4018         }
4019
4020       return inside_init;
4021     }
4022
4023   /* Come here only for records and arrays.  */
4024
4025   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4026     {
4027       error_init ("variable-sized object may not be initialized");
4028       return error_mark_node;
4029     }
4030
4031   error_init ("invalid initializer");
4032   return error_mark_node;
4033 }
4034 \f
4035 /* Handle initializers that use braces.  */
4036
4037 /* Type of object we are accumulating a constructor for.
4038    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4039 static tree constructor_type;
4040
4041 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4042    left to fill.  */
4043 static tree constructor_fields;
4044
4045 /* For an ARRAY_TYPE, this is the specified index
4046    at which to store the next element we get.  */
4047 static tree constructor_index;
4048
4049 /* For an ARRAY_TYPE, this is the maximum index.  */
4050 static tree constructor_max_index;
4051
4052 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4053 static tree constructor_unfilled_fields;
4054
4055 /* For an ARRAY_TYPE, this is the index of the first element
4056    not yet written out.  */
4057 static tree constructor_unfilled_index;
4058
4059 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4060    This is so we can generate gaps between fields, when appropriate.  */
4061 static tree constructor_bit_index;
4062
4063 /* If we are saving up the elements rather than allocating them,
4064    this is the list of elements so far (in reverse order,
4065    most recent first).  */
4066 static tree constructor_elements;
4067
4068 /* 1 if constructor should be incrementally stored into a constructor chain,
4069    0 if all the elements should be kept in AVL tree.  */
4070 static int constructor_incremental;
4071
4072 /* 1 if so far this constructor's elements are all compile-time constants.  */
4073 static int constructor_constant;
4074
4075 /* 1 if so far this constructor's elements are all valid address constants.  */
4076 static int constructor_simple;
4077
4078 /* 1 if this constructor is erroneous so far.  */
4079 static int constructor_erroneous;
4080
4081 /* Structure for managing pending initializer elements, organized as an
4082    AVL tree.  */
4083
4084 struct init_node
4085 {
4086   struct init_node *left, *right;
4087   struct init_node *parent;
4088   int balance;
4089   tree purpose;
4090   tree value;
4091 };
4092
4093 /* Tree of pending elements at this constructor level.
4094    These are elements encountered out of order
4095    which belong at places we haven't reached yet in actually
4096    writing the output.
4097    Will never hold tree nodes across GC runs.  */
4098 static struct init_node *constructor_pending_elts;
4099
4100 /* The SPELLING_DEPTH of this constructor.  */
4101 static int constructor_depth;
4102
4103 /* 0 if implicitly pushing constructor levels is allowed.  */
4104 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4105
4106 static int require_constant_value;
4107 static int require_constant_elements;
4108
4109 /* DECL node for which an initializer is being read.
4110    0 means we are reading a constructor expression
4111    such as (struct foo) {...}.  */
4112 static tree constructor_decl;
4113
4114 /* Nonzero if this is an initializer for a top-level decl.  */
4115 static int constructor_top_level;
4116
4117 /* Nonzero if there were any member designators in this initializer.  */
4118 static int constructor_designated;
4119
4120 /* Nesting depth of designator list.  */
4121 static int designator_depth;
4122
4123 /* Nonzero if there were diagnosed errors in this designator list.  */
4124 static int designator_errorneous;
4125
4126 \f
4127 /* This stack has a level for each implicit or explicit level of
4128    structuring in the initializer, including the outermost one.  It
4129    saves the values of most of the variables above.  */
4130
4131 struct constructor_range_stack;
4132
4133 struct constructor_stack
4134 {
4135   struct constructor_stack *next;
4136   tree type;
4137   tree fields;
4138   tree index;
4139   tree max_index;
4140   tree unfilled_index;
4141   tree unfilled_fields;
4142   tree bit_index;
4143   tree elements;
4144   struct init_node *pending_elts;
4145   int offset;
4146   int depth;
4147   /* If nonzero, this value should replace the entire
4148      constructor at this level.  */
4149   tree replacement_value;
4150   struct constructor_range_stack *range_stack;
4151   char constant;
4152   char simple;
4153   char implicit;
4154   char erroneous;
4155   char outer;
4156   char incremental;
4157   char designated;
4158 };
4159
4160 struct constructor_stack *constructor_stack;
4161
4162 /* This stack represents designators from some range designator up to
4163    the last designator in the list.  */
4164
4165 struct constructor_range_stack
4166 {
4167   struct constructor_range_stack *next, *prev;
4168   struct constructor_stack *stack;
4169   tree range_start;
4170   tree index;
4171   tree range_end;
4172   tree fields;
4173 };
4174
4175 struct constructor_range_stack *constructor_range_stack;
4176
4177 /* This stack records separate initializers that are nested.
4178    Nested initializers can't happen in ANSI C, but GNU C allows them
4179    in cases like { ... (struct foo) { ... } ... }.  */
4180
4181 struct initializer_stack
4182 {
4183   struct initializer_stack *next;
4184   tree decl;
4185   struct constructor_stack *constructor_stack;
4186   struct constructor_range_stack *constructor_range_stack;
4187   tree elements;
4188   struct spelling *spelling;
4189   struct spelling *spelling_base;
4190   int spelling_size;
4191   char top_level;
4192   char require_constant_value;
4193   char require_constant_elements;
4194 };
4195
4196 struct initializer_stack *initializer_stack;
4197 \f
4198 /* Prepare to parse and output the initializer for variable DECL.  */
4199
4200 void
4201 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
4202 {
4203   const char *locus;
4204   struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4205
4206   p->decl = constructor_decl;
4207   p->require_constant_value = require_constant_value;
4208   p->require_constant_elements = require_constant_elements;
4209   p->constructor_stack = constructor_stack;
4210   p->constructor_range_stack = constructor_range_stack;
4211   p->elements = constructor_elements;
4212   p->spelling = spelling;
4213   p->spelling_base = spelling_base;
4214   p->spelling_size = spelling_size;
4215   p->top_level = constructor_top_level;
4216   p->next = initializer_stack;
4217   initializer_stack = p;
4218
4219   constructor_decl = decl;
4220   constructor_designated = 0;
4221   constructor_top_level = top_level;
4222
4223   if (decl != 0)
4224     {
4225       require_constant_value = TREE_STATIC (decl);
4226       require_constant_elements
4227         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4228            /* For a scalar, you can always use any value to initialize,
4229               even within braces.  */
4230            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4231                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4232                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4233                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4234       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4235     }
4236   else
4237     {
4238       require_constant_value = 0;
4239       require_constant_elements = 0;
4240       locus = "(anonymous)";
4241     }
4242
4243   constructor_stack = 0;
4244   constructor_range_stack = 0;
4245
4246   missing_braces_mentioned = 0;
4247
4248   spelling_base = 0;
4249   spelling_size = 0;
4250   RESTORE_SPELLING_DEPTH (0);
4251
4252   if (locus)
4253     push_string (locus);
4254 }
4255
4256 void
4257 finish_init (void)
4258 {
4259   struct initializer_stack *p = initializer_stack;
4260
4261   /* Free the whole constructor stack of this initializer.  */
4262   while (constructor_stack)
4263     {
4264       struct constructor_stack *q = constructor_stack;
4265       constructor_stack = q->next;
4266       free (q);
4267     }
4268
4269   if (constructor_range_stack)
4270     abort ();
4271
4272   /* Pop back to the data of the outer initializer (if any).  */
4273   free (spelling_base);
4274
4275   constructor_decl = p->decl;
4276   require_constant_value = p->require_constant_value;
4277   require_constant_elements = p->require_constant_elements;
4278   constructor_stack = p->constructor_stack;
4279   constructor_range_stack = p->constructor_range_stack;
4280   constructor_elements = p->elements;
4281   spelling = p->spelling;
4282   spelling_base = p->spelling_base;
4283   spelling_size = p->spelling_size;
4284   constructor_top_level = p->top_level;
4285   initializer_stack = p->next;
4286   free (p);
4287 }
4288 \f
4289 /* Call here when we see the initializer is surrounded by braces.
4290    This is instead of a call to push_init_level;
4291    it is matched by a call to pop_init_level.
4292
4293    TYPE is the type to initialize, for a constructor expression.
4294    For an initializer for a decl, TYPE is zero.  */
4295
4296 void
4297 really_start_incremental_init (tree type)
4298 {
4299   struct constructor_stack *p = xmalloc (sizeof (struct constructor_stack));
4300
4301   if (type == 0)
4302     type = TREE_TYPE (constructor_decl);
4303
4304   if ((*targetm.vector_opaque_p) (type))
4305     error ("opaque vector types cannot be initialized");
4306
4307   p->type = constructor_type;
4308   p->fields = constructor_fields;
4309   p->index = constructor_index;
4310   p->max_index = constructor_max_index;
4311   p->unfilled_index = constructor_unfilled_index;
4312   p->unfilled_fields = constructor_unfilled_fields;
4313   p->bit_index = constructor_bit_index;
4314   p->elements = constructor_elements;
4315   p->constant = constructor_constant;
4316   p->simple = constructor_simple;
4317   p->erroneous = constructor_erroneous;
4318   p->pending_elts = constructor_pending_elts;
4319   p->depth = constructor_depth;
4320   p->replacement_value = 0;
4321   p->implicit = 0;
4322   p->range_stack = 0;
4323   p->outer = 0;
4324   p->incremental = constructor_incremental;
4325   p->designated = constructor_designated;
4326   p->next = 0;
4327   constructor_stack = p;
4328
4329   constructor_constant = 1;
4330   constructor_simple = 1;
4331   constructor_depth = SPELLING_DEPTH ();
4332   constructor_elements = 0;
4333   constructor_pending_elts = 0;
4334   constructor_type = type;
4335   constructor_incremental = 1;
4336   constructor_designated = 0;
4337   designator_depth = 0;
4338   designator_errorneous = 0;
4339
4340   if (TREE_CODE (constructor_type) == RECORD_TYPE
4341       || TREE_CODE (constructor_type) == UNION_TYPE)
4342     {
4343       constructor_fields = TYPE_FIELDS (constructor_type);
4344       /* Skip any nameless bit fields at the beginning.  */
4345       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4346              && DECL_NAME (constructor_fields) == 0)
4347         constructor_fields = TREE_CHAIN (constructor_fields);
4348
4349       constructor_unfilled_fields = constructor_fields;
4350       constructor_bit_index = bitsize_zero_node;
4351     }
4352   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4353     {
4354       if (TYPE_DOMAIN (constructor_type))
4355         {
4356           constructor_max_index
4357             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4358
4359           /* Detect non-empty initializations of zero-length arrays.  */
4360           if (constructor_max_index == NULL_TREE
4361               && TYPE_SIZE (constructor_type))
4362             constructor_max_index = build_int_2 (-1, -1);
4363
4364           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4365              to initialize VLAs will cause a proper error; avoid tree
4366              checking errors as well by setting a safe value.  */
4367           if (constructor_max_index
4368               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4369             constructor_max_index = build_int_2 (-1, -1);
4370
4371           constructor_index
4372             = convert (bitsizetype,
4373                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4374         }
4375       else
4376         constructor_index = bitsize_zero_node;
4377
4378       constructor_unfilled_index = constructor_index;
4379     }
4380   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4381     {
4382       /* Vectors are like simple fixed-size arrays.  */
4383       constructor_max_index =
4384         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4385       constructor_index = convert (bitsizetype, bitsize_zero_node);
4386       constructor_unfilled_index = constructor_index;
4387     }
4388   else
4389     {
4390       /* Handle the case of int x = {5}; */
4391       constructor_fields = constructor_type;
4392       constructor_unfilled_fields = constructor_type;
4393     }
4394 }
4395 \f
4396 /* Push down into a subobject, for initialization.
4397    If this is for an explicit set of braces, IMPLICIT is 0.
4398    If it is because the next element belongs at a lower level,
4399    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4400
4401 void
4402 push_init_level (int implicit)
4403 {
4404   struct constructor_stack *p;
4405   tree value = NULL_TREE;
4406
4407   /* If we've exhausted any levels that didn't have braces,
4408      pop them now.  */
4409   while (constructor_stack->implicit)
4410     {
4411       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4412            || TREE_CODE (constructor_type) == UNION_TYPE)
4413           && constructor_fields == 0)
4414         process_init_element (pop_init_level (1));
4415       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4416                && constructor_max_index
4417                && tree_int_cst_lt (constructor_max_index, constructor_index))
4418         process_init_element (pop_init_level (1));
4419       else
4420         break;
4421     }
4422
4423   /* Unless this is an explicit brace, we need to preserve previous
4424      content if any.  */
4425   if (implicit)
4426     {
4427       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4428            || TREE_CODE (constructor_type) == UNION_TYPE)
4429           && constructor_fields)
4430         value = find_init_member (constructor_fields);
4431       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4432         value = find_init_member (constructor_index);
4433     }
4434
4435   p = xmalloc (sizeof (struct constructor_stack));
4436   p->type = constructor_type;
4437   p->fields = constructor_fields;
4438   p->index = constructor_index;
4439   p->max_index = constructor_max_index;
4440   p->unfilled_index = constructor_unfilled_index;
4441   p->unfilled_fields = constructor_unfilled_fields;
4442   p->bit_index = constructor_bit_index;
4443   p->elements = constructor_elements;
4444   p->constant = constructor_constant;
4445   p->simple = constructor_simple;
4446   p->erroneous = constructor_erroneous;
4447   p->pending_elts = constructor_pending_elts;
4448   p->depth = constructor_depth;
4449   p->replacement_value = 0;
4450   p->implicit = implicit;
4451   p->outer = 0;
4452   p->incremental = constructor_incremental;
4453   p->designated = constructor_designated;
4454   p->next = constructor_stack;
4455   p->range_stack = 0;
4456   constructor_stack = p;
4457
4458   constructor_constant = 1;
4459   constructor_simple = 1;
4460   constructor_depth = SPELLING_DEPTH ();
4461   constructor_elements = 0;
4462   constructor_incremental = 1;
4463   constructor_designated = 0;
4464   constructor_pending_elts = 0;
4465   if (!implicit)
4466     {
4467       p->range_stack = constructor_range_stack;
4468       constructor_range_stack = 0;
4469       designator_depth = 0;
4470       designator_errorneous = 0;
4471     }
4472
4473   /* Don't die if an entire brace-pair level is superfluous
4474      in the containing level.  */
4475   if (constructor_type == 0)
4476     ;
4477   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4478            || TREE_CODE (constructor_type) == UNION_TYPE)
4479     {
4480       /* Don't die if there are extra init elts at the end.  */
4481       if (constructor_fields == 0)
4482         constructor_type = 0;
4483       else
4484         {
4485           constructor_type = TREE_TYPE (constructor_fields);
4486           push_member_name (constructor_fields);
4487           constructor_depth++;
4488         }
4489     }
4490   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4491     {
4492       constructor_type = TREE_TYPE (constructor_type);
4493       push_array_bounds (tree_low_cst (constructor_index, 0));
4494       constructor_depth++;
4495     }
4496
4497   if (constructor_type == 0)
4498     {
4499       error_init ("extra brace group at end of initializer");
4500       constructor_fields = 0;
4501       constructor_unfilled_fields = 0;
4502       return;
4503     }
4504
4505   if (value && TREE_CODE (value) == CONSTRUCTOR)
4506     {
4507       constructor_constant = TREE_CONSTANT (value);
4508       constructor_simple = TREE_STATIC (value);
4509       constructor_elements = CONSTRUCTOR_ELTS (value);
4510       if (constructor_elements
4511           && (TREE_CODE (constructor_type) == RECORD_TYPE
4512               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4513         set_nonincremental_init ();
4514     }
4515
4516   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4517     {
4518       missing_braces_mentioned = 1;
4519       warning_init ("missing braces around initializer");
4520     }
4521
4522   if (TREE_CODE (constructor_type) == RECORD_TYPE
4523            || TREE_CODE (constructor_type) == UNION_TYPE)
4524     {
4525       constructor_fields = TYPE_FIELDS (constructor_type);
4526       /* Skip any nameless bit fields at the beginning.  */
4527       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4528              && DECL_NAME (constructor_fields) == 0)
4529         constructor_fields = TREE_CHAIN (constructor_fields);
4530
4531       constructor_unfilled_fields = constructor_fields;
4532       constructor_bit_index = bitsize_zero_node;
4533     }
4534   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4535     {
4536       /* Vectors are like simple fixed-size arrays.  */
4537       constructor_max_index =
4538         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4539       constructor_index = convert (bitsizetype, integer_zero_node);
4540       constructor_unfilled_index = constructor_index;
4541     }
4542   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4543     {
4544       if (TYPE_DOMAIN (constructor_type))
4545         {
4546           constructor_max_index
4547             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4548
4549           /* Detect non-empty initializations of zero-length arrays.  */
4550           if (constructor_max_index == NULL_TREE
4551               && TYPE_SIZE (constructor_type))
4552             constructor_max_index = build_int_2 (-1, -1);
4553
4554           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4555              to initialize VLAs will cause a proper error; avoid tree
4556              checking errors as well by setting a safe value.  */
4557           if (constructor_max_index
4558               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4559             constructor_max_index = build_int_2 (-1, -1);
4560
4561           constructor_index
4562             = convert (bitsizetype,
4563                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4564         }
4565       else
4566         constructor_index = bitsize_zero_node;
4567
4568       constructor_unfilled_index = constructor_index;
4569       if (value && TREE_CODE (value) == STRING_CST)
4570         {
4571           /* We need to split the char/wchar array into individual
4572              characters, so that we don't have to special case it
4573              everywhere.  */
4574           set_nonincremental_init_from_string (value);
4575         }
4576     }
4577   else
4578     {
4579       warning_init ("braces around scalar initializer");
4580       constructor_fields = constructor_type;
4581       constructor_unfilled_fields = constructor_type;
4582     }
4583 }
4584
4585 /* At the end of an implicit or explicit brace level,
4586    finish up that level of constructor.
4587    If we were outputting the elements as they are read, return 0
4588    from inner levels (process_init_element ignores that),
4589    but return error_mark_node from the outermost level
4590    (that's what we want to put in DECL_INITIAL).
4591    Otherwise, return a CONSTRUCTOR expression.  */
4592
4593 tree
4594 pop_init_level (int implicit)
4595 {
4596   struct constructor_stack *p;
4597   tree constructor = 0;
4598
4599   if (implicit == 0)
4600     {
4601       /* When we come to an explicit close brace,
4602          pop any inner levels that didn't have explicit braces.  */
4603       while (constructor_stack->implicit)
4604         process_init_element (pop_init_level (1));
4605
4606       if (constructor_range_stack)
4607         abort ();
4608     }
4609
4610   p = constructor_stack;
4611
4612   /* Error for initializing a flexible array member, or a zero-length
4613      array member in an inappropriate context.  */
4614   if (constructor_type && constructor_fields
4615       && TREE_CODE (constructor_type) == ARRAY_TYPE
4616       && TYPE_DOMAIN (constructor_type)
4617       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4618     {
4619       /* Silently discard empty initializations.  The parser will
4620          already have pedwarned for empty brackets.  */
4621       if (integer_zerop (constructor_unfilled_index))
4622         constructor_type = NULL_TREE;
4623       else if (! TYPE_SIZE (constructor_type))
4624         {
4625           if (constructor_depth > 2)
4626             error_init ("initialization of flexible array member in a nested context");
4627           else if (pedantic)
4628             pedwarn_init ("initialization of a flexible array member");
4629
4630           /* We have already issued an error message for the existence
4631              of a flexible array member not at the end of the structure.
4632              Discard the initializer so that we do not abort later.  */
4633           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4634             constructor_type = NULL_TREE;
4635         }
4636       else
4637         /* Zero-length arrays are no longer special, so we should no longer
4638            get here.  */
4639         abort ();
4640     }
4641
4642   /* Warn when some struct elements are implicitly initialized to zero.  */
4643   if (extra_warnings
4644       && constructor_type
4645       && TREE_CODE (constructor_type) == RECORD_TYPE
4646       && constructor_unfilled_fields)
4647     {
4648         /* Do not warn for flexible array members or zero-length arrays.  */
4649         while (constructor_unfilled_fields
4650                && (! DECL_SIZE (constructor_unfilled_fields)
4651                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4652           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4653
4654         /* Do not warn if this level of the initializer uses member
4655            designators; it is likely to be deliberate.  */
4656         if (constructor_unfilled_fields && !constructor_designated)
4657           {
4658             push_member_name (constructor_unfilled_fields);
4659             warning_init ("missing initializer");
4660             RESTORE_SPELLING_DEPTH (constructor_depth);
4661           }
4662     }
4663
4664   /* Now output all pending elements.  */
4665   constructor_incremental = 1;
4666   output_pending_init_elements (1);
4667
4668   /* Pad out the end of the structure.  */
4669   if (p->replacement_value)
4670     /* If this closes a superfluous brace pair,
4671        just pass out the element between them.  */
4672     constructor = p->replacement_value;
4673   else if (constructor_type == 0)
4674     ;
4675   else if (TREE_CODE (constructor_type) != RECORD_TYPE
4676            && TREE_CODE (constructor_type) != UNION_TYPE
4677            && TREE_CODE (constructor_type) != ARRAY_TYPE
4678            && TREE_CODE (constructor_type) != VECTOR_TYPE)
4679     {
4680       /* A nonincremental scalar initializer--just return
4681          the element, after verifying there is just one.  */
4682       if (constructor_elements == 0)
4683         {
4684           if (!constructor_erroneous)
4685             error_init ("empty scalar initializer");
4686           constructor = error_mark_node;
4687         }
4688       else if (TREE_CHAIN (constructor_elements) != 0)
4689         {
4690           error_init ("extra elements in scalar initializer");
4691           constructor = TREE_VALUE (constructor_elements);
4692         }
4693       else
4694         constructor = TREE_VALUE (constructor_elements);
4695     }
4696   else
4697     {
4698       if (constructor_erroneous)
4699         constructor = error_mark_node;
4700       else
4701         {
4702           constructor = build_constructor (constructor_type,
4703                                            nreverse (constructor_elements));
4704           if (constructor_constant)
4705             TREE_CONSTANT (constructor) = 1;
4706           if (constructor_constant && constructor_simple)
4707             TREE_STATIC (constructor) = 1;
4708         }
4709     }
4710
4711   constructor_type = p->type;
4712   constructor_fields = p->fields;
4713   constructor_index = p->index;
4714   constructor_max_index = p->max_index;
4715   constructor_unfilled_index = p->unfilled_index;
4716   constructor_unfilled_fields = p->unfilled_fields;
4717   constructor_bit_index = p->bit_index;
4718   constructor_elements = p->elements;
4719   constructor_constant = p->constant;
4720   constructor_simple = p->simple;
4721   constructor_erroneous = p->erroneous;
4722   constructor_incremental = p->incremental;
4723   constructor_designated = p->designated;
4724   constructor_pending_elts = p->pending_elts;
4725   constructor_depth = p->depth;
4726   if (!p->implicit)
4727     constructor_range_stack = p->range_stack;
4728   RESTORE_SPELLING_DEPTH (constructor_depth);
4729
4730   constructor_stack = p->next;
4731   free (p);
4732
4733   if (constructor == 0)
4734     {
4735       if (constructor_stack == 0)
4736         return error_mark_node;
4737       return NULL_TREE;
4738     }
4739   return constructor;
4740 }
4741
4742 /* Common handling for both array range and field name designators.
4743    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
4744
4745 static int
4746 set_designator (int array)
4747 {
4748   tree subtype;
4749   enum tree_code subcode;
4750
4751   /* Don't die if an entire brace-pair level is superfluous
4752      in the containing level.  */
4753   if (constructor_type == 0)
4754     return 1;
4755
4756   /* If there were errors in this designator list already, bail out silently.  */
4757   if (designator_errorneous)
4758     return 1;
4759
4760   if (!designator_depth)
4761     {
4762       if (constructor_range_stack)
4763         abort ();
4764
4765       /* Designator list starts at the level of closest explicit
4766          braces.  */
4767       while (constructor_stack->implicit)
4768         process_init_element (pop_init_level (1));
4769       constructor_designated = 1;
4770       return 0;
4771     }
4772
4773   if (constructor_no_implicit)
4774     {
4775       error_init ("initialization designators may not nest");
4776       return 1;
4777     }
4778
4779   if (TREE_CODE (constructor_type) == RECORD_TYPE
4780       || TREE_CODE (constructor_type) == UNION_TYPE)
4781     {
4782       subtype = TREE_TYPE (constructor_fields);
4783       if (subtype != error_mark_node)
4784         subtype = TYPE_MAIN_VARIANT (subtype);
4785     }
4786   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4787     {
4788       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
4789     }
4790   else
4791     abort ();
4792
4793   subcode = TREE_CODE (subtype);
4794   if (array && subcode != ARRAY_TYPE)
4795     {
4796       error_init ("array index in non-array initializer");
4797       return 1;
4798     }
4799   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
4800     {
4801       error_init ("field name not in record or union initializer");
4802       return 1;
4803     }
4804
4805   constructor_designated = 1;
4806   push_init_level (2);
4807   return 0;
4808 }
4809
4810 /* If there are range designators in designator list, push a new designator
4811    to constructor_range_stack.  RANGE_END is end of such stack range or
4812    NULL_TREE if there is no range designator at this level.  */
4813
4814 static void
4815 push_range_stack (tree range_end)
4816 {
4817   struct constructor_range_stack *p;
4818
4819   p = ggc_alloc (sizeof (struct constructor_range_stack));
4820   p->prev = constructor_range_stack;
4821   p->next = 0;
4822   p->fields = constructor_fields;
4823   p->range_start = constructor_index;
4824   p->index = constructor_index;
4825   p->stack = constructor_stack;
4826   p->range_end = range_end;
4827   if (constructor_range_stack)
4828     constructor_range_stack->next = p;
4829   constructor_range_stack = p;
4830 }
4831
4832 /* Within an array initializer, specify the next index to be initialized.
4833    FIRST is that index.  If LAST is nonzero, then initialize a range
4834    of indices, running from FIRST through LAST.  */
4835
4836 void
4837 set_init_index (tree first, tree last)
4838 {
4839   if (set_designator (1))
4840     return;
4841
4842   designator_errorneous = 1;
4843
4844   while ((TREE_CODE (first) == NOP_EXPR
4845           || TREE_CODE (first) == CONVERT_EXPR
4846           || TREE_CODE (first) == NON_LVALUE_EXPR)
4847          && (TYPE_MODE (TREE_TYPE (first))
4848              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
4849     first = TREE_OPERAND (first, 0);
4850
4851   if (last)
4852     while ((TREE_CODE (last) == NOP_EXPR
4853             || TREE_CODE (last) == CONVERT_EXPR
4854             || TREE_CODE (last) == NON_LVALUE_EXPR)
4855            && (TYPE_MODE (TREE_TYPE (last))
4856                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
4857       last = TREE_OPERAND (last, 0);
4858
4859   if (TREE_CODE (first) != INTEGER_CST)
4860     error_init ("nonconstant array index in initializer");
4861   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
4862     error_init ("nonconstant array index in initializer");
4863   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
4864     error_init ("array index in non-array initializer");
4865   else if (tree_int_cst_sgn (first) == -1)
4866     error_init ("array index in initializer exceeds array bounds");
4867   else if (constructor_max_index
4868            && tree_int_cst_lt (constructor_max_index, first))
4869     error_init ("array index in initializer exceeds array bounds");
4870   else
4871     {
4872       constructor_index = convert (bitsizetype, first);
4873
4874       if (last)
4875         {
4876           if (tree_int_cst_equal (first, last))
4877             last = 0;
4878           else if (tree_int_cst_lt (last, first))
4879             {
4880               error_init ("empty index range in initializer");
4881               last = 0;
4882             }
4883           else
4884             {
4885               last = convert (bitsizetype, last);
4886               if (constructor_max_index != 0
4887                   && tree_int_cst_lt (constructor_max_index, last))
4888                 {
4889                   error_init ("array index range in initializer exceeds array bounds");
4890                   last = 0;
4891                 }
4892             }
4893         }
4894
4895       designator_depth++;
4896       designator_errorneous = 0;
4897       if (constructor_range_stack || last)
4898         push_range_stack (last);
4899     }
4900 }
4901
4902 /* Within a struct initializer, specify the next field to be initialized.  */
4903
4904 void
4905 set_init_label (tree fieldname)
4906 {
4907   tree tail;
4908
4909   if (set_designator (0))
4910     return;
4911
4912   designator_errorneous = 1;
4913
4914   if (TREE_CODE (constructor_type) != RECORD_TYPE
4915       && TREE_CODE (constructor_type) != UNION_TYPE)
4916     {
4917       error_init ("field name not in record or union initializer");
4918       return;
4919     }
4920
4921   for (tail = TYPE_FIELDS (constructor_type); tail;
4922        tail = TREE_CHAIN (tail))
4923     {
4924       if (DECL_NAME (tail) == fieldname)
4925         break;
4926     }
4927
4928   if (tail == 0)
4929     error ("unknown field `%s' specified in initializer",
4930            IDENTIFIER_POINTER (fieldname));
4931   else
4932     {
4933       constructor_fields = tail;
4934       designator_depth++;
4935       designator_errorneous = 0;
4936       if (constructor_range_stack)
4937         push_range_stack (NULL_TREE);
4938     }
4939 }
4940 \f
4941 /* Add a new initializer to the tree of pending initializers.  PURPOSE
4942    identifies the initializer, either array index or field in a structure.
4943    VALUE is the value of that index or field.  */
4944
4945 static void
4946 add_pending_init (tree purpose, tree value)
4947 {
4948   struct init_node *p, **q, *r;
4949
4950   q = &constructor_pending_elts;
4951   p = 0;
4952
4953   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4954     {
4955       while (*q != 0)
4956         {
4957           p = *q;
4958           if (tree_int_cst_lt (purpose, p->purpose))
4959             q = &p->left;
4960           else if (tree_int_cst_lt (p->purpose, purpose))
4961             q = &p->right;
4962           else
4963             {
4964               if (TREE_SIDE_EFFECTS (p->value))
4965                 warning_init ("initialized field with side-effects overwritten");
4966               p->value = value;
4967               return;
4968             }
4969         }
4970     }
4971   else
4972     {
4973       tree bitpos;
4974
4975       bitpos = bit_position (purpose);
4976       while (*q != NULL)
4977         {
4978           p = *q;
4979           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
4980             q = &p->left;
4981           else if (p->purpose != purpose)
4982             q = &p->right;
4983           else
4984             {
4985               if (TREE_SIDE_EFFECTS (p->value))
4986                 warning_init ("initialized field with side-effects overwritten");
4987               p->value = value;
4988               return;
4989             }
4990         }
4991     }
4992
4993   r = ggc_alloc (sizeof (struct init_node));
4994   r->purpose = purpose;
4995   r->value = value;
4996
4997   *q = r;
4998   r->parent = p;
4999   r->left = 0;
5000   r->right = 0;
5001   r->balance = 0;
5002
5003   while (p)
5004     {
5005       struct init_node *s;
5006
5007       if (r == p->left)
5008         {
5009           if (p->balance == 0)
5010             p->balance = -1;
5011           else if (p->balance < 0)
5012             {
5013               if (r->balance < 0)
5014                 {
5015                   /* L rotation.  */
5016                   p->left = r->right;
5017                   if (p->left)
5018                     p->left->parent = p;
5019                   r->right = p;
5020
5021                   p->balance = 0;
5022                   r->balance = 0;
5023
5024                   s = p->parent;
5025                   p->parent = r;
5026                   r->parent = s;
5027                   if (s)
5028                     {
5029                       if (s->left == p)
5030                         s->left = r;
5031                       else
5032                         s->right = r;
5033                     }
5034                   else
5035                     constructor_pending_elts = r;
5036                 }
5037               else
5038                 {
5039                   /* LR rotation.  */
5040                   struct init_node *t = r->right;
5041
5042                   r->right = t->left;
5043                   if (r->right)
5044                     r->right->parent = r;
5045                   t->left = r;
5046
5047                   p->left = t->right;
5048                   if (p->left)
5049                     p->left->parent = p;
5050                   t->right = p;
5051
5052                   p->balance = t->balance < 0;
5053                   r->balance = -(t->balance > 0);
5054                   t->balance = 0;
5055
5056                   s = p->parent;
5057                   p->parent = t;
5058                   r->parent = t;
5059                   t->parent = s;
5060                   if (s)
5061                     {
5062                       if (s->left == p)
5063                         s->left = t;
5064                       else
5065                         s->right = t;
5066                     }
5067                   else
5068                     constructor_pending_elts = t;
5069                 }
5070               break;
5071             }
5072           else
5073             {
5074               /* p->balance == +1; growth of left side balances the node.  */
5075               p->balance = 0;
5076               break;
5077             }
5078         }
5079       else /* r == p->right */
5080         {
5081           if (p->balance == 0)
5082             /* Growth propagation from right side.  */
5083             p->balance++;
5084           else if (p->balance > 0)
5085             {
5086               if (r->balance > 0)
5087                 {
5088                   /* R rotation.  */
5089                   p->right = r->left;
5090                   if (p->right)
5091                     p->right->parent = p;
5092                   r->left = p;
5093
5094                   p->balance = 0;
5095                   r->balance = 0;
5096
5097                   s = p->parent;
5098                   p->parent = r;
5099                   r->parent = s;
5100                   if (s)
5101                     {
5102                       if (s->left == p)
5103                         s->left = r;
5104                       else
5105                         s->right = r;
5106                     }
5107                   else
5108                     constructor_pending_elts = r;
5109                 }
5110               else /* r->balance == -1 */
5111                 {
5112                   /* RL rotation */
5113                   struct init_node *t = r->left;
5114
5115                   r->left = t->right;
5116                   if (r->left)
5117                     r->left->parent = r;
5118                   t->right = r;
5119
5120                   p->right = t->left;
5121                   if (p->right)
5122                     p->right->parent = p;
5123                   t->left = p;
5124
5125                   r->balance = (t->balance < 0);
5126                   p->balance = -(t->balance > 0);
5127                   t->balance = 0;
5128
5129                   s = p->parent;
5130                   p->parent = t;
5131                   r->parent = t;
5132                   t->parent = s;
5133                   if (s)
5134                     {
5135                       if (s->left == p)
5136                         s->left = t;
5137                       else
5138                         s->right = t;
5139                     }
5140                   else
5141                     constructor_pending_elts = t;
5142                 }
5143               break;
5144             }
5145           else
5146             {
5147               /* p->balance == -1; growth of right side balances the node.  */
5148               p->balance = 0;
5149               break;
5150             }
5151         }
5152
5153       r = p;
5154       p = p->parent;
5155     }
5156 }
5157
5158 /* Build AVL tree from a sorted chain.  */
5159
5160 static void
5161 set_nonincremental_init (void)
5162 {
5163   tree chain;
5164
5165   if (TREE_CODE (constructor_type) != RECORD_TYPE
5166       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5167     return;
5168
5169   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5170     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5171   constructor_elements = 0;
5172   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5173     {
5174       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5175       /* Skip any nameless bit fields at the beginning.  */
5176       while (constructor_unfilled_fields != 0
5177              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5178              && DECL_NAME (constructor_unfilled_fields) == 0)
5179         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5180
5181     }
5182   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5183     {
5184       if (TYPE_DOMAIN (constructor_type))
5185         constructor_unfilled_index
5186             = convert (bitsizetype,
5187                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5188       else
5189         constructor_unfilled_index = bitsize_zero_node;
5190     }
5191   constructor_incremental = 0;
5192 }
5193
5194 /* Build AVL tree from a string constant.  */
5195
5196 static void
5197 set_nonincremental_init_from_string (tree str)
5198 {
5199   tree value, purpose, type;
5200   HOST_WIDE_INT val[2];
5201   const char *p, *end;
5202   int byte, wchar_bytes, charwidth, bitpos;
5203
5204   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5205     abort ();
5206
5207   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5208       == TYPE_PRECISION (char_type_node))
5209     wchar_bytes = 1;
5210   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5211            == TYPE_PRECISION (wchar_type_node))
5212     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5213   else
5214     abort ();
5215
5216   charwidth = TYPE_PRECISION (char_type_node);
5217   type = TREE_TYPE (constructor_type);
5218   p = TREE_STRING_POINTER (str);
5219   end = p + TREE_STRING_LENGTH (str);
5220
5221   for (purpose = bitsize_zero_node;
5222        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5223        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5224     {
5225       if (wchar_bytes == 1)
5226         {
5227           val[1] = (unsigned char) *p++;
5228           val[0] = 0;
5229         }
5230       else
5231         {
5232           val[0] = 0;
5233           val[1] = 0;
5234           for (byte = 0; byte < wchar_bytes; byte++)
5235             {
5236               if (BYTES_BIG_ENDIAN)
5237                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5238               else
5239                 bitpos = byte * charwidth;
5240               val[bitpos < HOST_BITS_PER_WIDE_INT]
5241                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5242                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5243             }
5244         }
5245
5246       if (!TREE_UNSIGNED (type))
5247         {
5248           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5249           if (bitpos < HOST_BITS_PER_WIDE_INT)
5250             {
5251               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5252                 {
5253                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5254                   val[0] = -1;
5255                 }
5256             }
5257           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5258             {
5259               if (val[1] < 0)
5260                 val[0] = -1;
5261             }
5262           else if (val[0] & (((HOST_WIDE_INT) 1)
5263                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5264             val[0] |= ((HOST_WIDE_INT) -1)
5265                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5266         }
5267
5268       value = build_int_2 (val[1], val[0]);
5269       TREE_TYPE (value) = type;
5270       add_pending_init (purpose, value);
5271     }
5272
5273   constructor_incremental = 0;
5274 }
5275
5276 /* Return value of FIELD in pending initializer or zero if the field was
5277    not initialized yet.  */
5278
5279 static tree
5280 find_init_member (tree field)
5281 {
5282   struct init_node *p;
5283
5284   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5285     {
5286       if (constructor_incremental
5287           && tree_int_cst_lt (field, constructor_unfilled_index))
5288         set_nonincremental_init ();
5289
5290       p = constructor_pending_elts;
5291       while (p)
5292         {
5293           if (tree_int_cst_lt (field, p->purpose))
5294             p = p->left;
5295           else if (tree_int_cst_lt (p->purpose, field))
5296             p = p->right;
5297           else
5298             return p->value;
5299         }
5300     }
5301   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5302     {
5303       tree bitpos = bit_position (field);
5304
5305       if (constructor_incremental
5306           && (!constructor_unfilled_fields
5307               || tree_int_cst_lt (bitpos,
5308                                   bit_position (constructor_unfilled_fields))))
5309         set_nonincremental_init ();
5310
5311       p = constructor_pending_elts;
5312       while (p)
5313         {
5314           if (field == p->purpose)
5315             return p->value;
5316           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5317             p = p->left;
5318           else
5319             p = p->right;
5320         }
5321     }
5322   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5323     {
5324       if (constructor_elements
5325           && TREE_PURPOSE (constructor_elements) == field)
5326         return TREE_VALUE (constructor_elements);
5327     }
5328   return 0;
5329 }
5330
5331 /* "Output" the next constructor element.
5332    At top level, really output it to assembler code now.
5333    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5334    TYPE is the data type that the containing data type wants here.
5335    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5336
5337    PENDING if non-nil means output pending elements that belong
5338    right after this element.  (PENDING is normally 1;
5339    it is 0 while outputting pending elements, to avoid recursion.)  */
5340
5341 static void
5342 output_init_element (tree value, tree type, tree field, int pending)
5343 {
5344   if (type == error_mark_node)
5345     {
5346       constructor_erroneous = 1;
5347       return;
5348     }
5349   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5350       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5351           && !(TREE_CODE (value) == STRING_CST
5352                && TREE_CODE (type) == ARRAY_TYPE
5353                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5354           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5355                          TYPE_MAIN_VARIANT (type), COMPARE_STRICT)))
5356     value = default_conversion (value);
5357
5358   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5359       && require_constant_value && !flag_isoc99 && pending)
5360     {
5361       /* As an extension, allow initializing objects with static storage
5362          duration with compound literals (which are then treated just as
5363          the brace enclosed list they contain).  */
5364       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5365       value = DECL_INITIAL (decl);
5366     }
5367
5368   if (value == error_mark_node)
5369     constructor_erroneous = 1;
5370   else if (!TREE_CONSTANT (value))
5371     constructor_constant = 0;
5372   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5373            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5374                 || TREE_CODE (constructor_type) == UNION_TYPE)
5375                && DECL_C_BIT_FIELD (field)
5376                && TREE_CODE (value) != INTEGER_CST))
5377     constructor_simple = 0;
5378
5379   if (require_constant_value && ! TREE_CONSTANT (value))
5380     {
5381       error_init ("initializer element is not constant");
5382       value = error_mark_node;
5383     }
5384   else if (require_constant_elements
5385            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5386     pedwarn ("initializer element is not computable at load time");
5387
5388   /* If this field is empty (and not at the end of structure),
5389      don't do anything other than checking the initializer.  */
5390   if (field
5391       && (TREE_TYPE (field) == error_mark_node
5392           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5393               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5394               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5395                   || TREE_CHAIN (field)))))
5396     return;
5397
5398   value = digest_init (type, value, require_constant_value);
5399   if (value == error_mark_node)
5400     {
5401       constructor_erroneous = 1;
5402       return;
5403     }
5404
5405   /* If this element doesn't come next in sequence,
5406      put it on constructor_pending_elts.  */
5407   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5408       && (!constructor_incremental
5409           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5410     {
5411       if (constructor_incremental
5412           && tree_int_cst_lt (field, constructor_unfilled_index))
5413         set_nonincremental_init ();
5414
5415       add_pending_init (field, value);
5416       return;
5417     }
5418   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5419            && (!constructor_incremental
5420                || field != constructor_unfilled_fields))
5421     {
5422       /* We do this for records but not for unions.  In a union,
5423          no matter which field is specified, it can be initialized
5424          right away since it starts at the beginning of the union.  */
5425       if (constructor_incremental)
5426         {
5427           if (!constructor_unfilled_fields)
5428             set_nonincremental_init ();
5429           else
5430             {
5431               tree bitpos, unfillpos;
5432
5433               bitpos = bit_position (field);
5434               unfillpos = bit_position (constructor_unfilled_fields);
5435
5436               if (tree_int_cst_lt (bitpos, unfillpos))
5437                 set_nonincremental_init ();
5438             }
5439         }
5440
5441       add_pending_init (field, value);
5442       return;
5443     }
5444   else if (TREE_CODE (constructor_type) == UNION_TYPE
5445            && constructor_elements)
5446     {
5447       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5448         warning_init ("initialized field with side-effects overwritten");
5449
5450       /* We can have just one union field set.  */
5451       constructor_elements = 0;
5452     }
5453
5454   /* Otherwise, output this element either to
5455      constructor_elements or to the assembler file.  */
5456
5457   if (field && TREE_CODE (field) == INTEGER_CST)
5458     field = copy_node (field);
5459   constructor_elements
5460     = tree_cons (field, value, constructor_elements);
5461
5462   /* Advance the variable that indicates sequential elements output.  */
5463   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5464     constructor_unfilled_index
5465       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5466                     bitsize_one_node);
5467   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5468     {
5469       constructor_unfilled_fields
5470         = TREE_CHAIN (constructor_unfilled_fields);
5471
5472       /* Skip any nameless bit fields.  */
5473       while (constructor_unfilled_fields != 0
5474              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5475              && DECL_NAME (constructor_unfilled_fields) == 0)
5476         constructor_unfilled_fields =
5477           TREE_CHAIN (constructor_unfilled_fields);
5478     }
5479   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5480     constructor_unfilled_fields = 0;
5481
5482   /* Now output any pending elements which have become next.  */
5483   if (pending)
5484     output_pending_init_elements (0);
5485 }
5486
5487 /* Output any pending elements which have become next.
5488    As we output elements, constructor_unfilled_{fields,index}
5489    advances, which may cause other elements to become next;
5490    if so, they too are output.
5491
5492    If ALL is 0, we return when there are
5493    no more pending elements to output now.
5494
5495    If ALL is 1, we output space as necessary so that
5496    we can output all the pending elements.  */
5497
5498 static void
5499 output_pending_init_elements (int all)
5500 {
5501   struct init_node *elt = constructor_pending_elts;
5502   tree next;
5503
5504  retry:
5505
5506   /* Look through the whole pending tree.
5507      If we find an element that should be output now,
5508      output it.  Otherwise, set NEXT to the element
5509      that comes first among those still pending.  */
5510
5511   next = 0;
5512   while (elt)
5513     {
5514       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5515         {
5516           if (tree_int_cst_equal (elt->purpose,
5517                                   constructor_unfilled_index))
5518             output_init_element (elt->value,
5519                                  TREE_TYPE (constructor_type),
5520                                  constructor_unfilled_index, 0);
5521           else if (tree_int_cst_lt (constructor_unfilled_index,
5522                                     elt->purpose))
5523             {
5524               /* Advance to the next smaller node.  */
5525               if (elt->left)
5526                 elt = elt->left;
5527               else
5528                 {
5529                   /* We have reached the smallest node bigger than the
5530                      current unfilled index.  Fill the space first.  */
5531                   next = elt->purpose;
5532                   break;
5533                 }
5534             }
5535           else
5536             {
5537               /* Advance to the next bigger node.  */
5538               if (elt->right)
5539                 elt = elt->right;
5540               else
5541                 {
5542                   /* We have reached the biggest node in a subtree.  Find
5543                      the parent of it, which is the next bigger node.  */
5544                   while (elt->parent && elt->parent->right == elt)
5545                     elt = elt->parent;
5546                   elt = elt->parent;
5547                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5548                                               elt->purpose))
5549                     {
5550                       next = elt->purpose;
5551                       break;
5552                     }
5553                 }
5554             }
5555         }
5556       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5557                || TREE_CODE (constructor_type) == UNION_TYPE)
5558         {
5559           tree ctor_unfilled_bitpos, elt_bitpos;
5560
5561           /* If the current record is complete we are done.  */
5562           if (constructor_unfilled_fields == 0)
5563             break;
5564
5565           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5566           elt_bitpos = bit_position (elt->purpose);
5567           /* We can't compare fields here because there might be empty
5568              fields in between.  */
5569           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5570             {
5571               constructor_unfilled_fields = elt->purpose;
5572               output_init_element (elt->value, TREE_TYPE (elt->purpose),
5573                                    elt->purpose, 0);
5574             }
5575           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5576             {
5577               /* Advance to the next smaller node.  */
5578               if (elt->left)
5579                 elt = elt->left;
5580               else
5581                 {
5582                   /* We have reached the smallest node bigger than the
5583                      current unfilled field.  Fill the space first.  */
5584                   next = elt->purpose;
5585                   break;
5586                 }
5587             }
5588           else
5589             {
5590               /* Advance to the next bigger node.  */
5591               if (elt->right)
5592                 elt = elt->right;
5593               else
5594                 {
5595                   /* We have reached the biggest node in a subtree.  Find
5596                      the parent of it, which is the next bigger node.  */
5597                   while (elt->parent && elt->parent->right == elt)
5598                     elt = elt->parent;
5599                   elt = elt->parent;
5600                   if (elt
5601                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5602                                            bit_position (elt->purpose))))
5603                     {
5604                       next = elt->purpose;
5605                       break;
5606                     }
5607                 }
5608             }
5609         }
5610     }
5611
5612   /* Ordinarily return, but not if we want to output all
5613      and there are elements left.  */
5614   if (! (all && next != 0))
5615     return;
5616
5617   /* If it's not incremental, just skip over the gap, so that after
5618      jumping to retry we will output the next successive element.  */
5619   if (TREE_CODE (constructor_type) == RECORD_TYPE
5620       || TREE_CODE (constructor_type) == UNION_TYPE)
5621     constructor_unfilled_fields = next;
5622   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5623     constructor_unfilled_index = next;
5624
5625   /* ELT now points to the node in the pending tree with the next
5626      initializer to output.  */
5627   goto retry;
5628 }
5629 \f
5630 /* Add one non-braced element to the current constructor level.
5631    This adjusts the current position within the constructor's type.
5632    This may also start or terminate implicit levels
5633    to handle a partly-braced initializer.
5634
5635    Once this has found the correct level for the new element,
5636    it calls output_init_element.  */
5637
5638 void
5639 process_init_element (tree value)
5640 {
5641   tree orig_value = value;
5642   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
5643
5644   designator_depth = 0;
5645   designator_errorneous = 0;
5646
5647   /* Handle superfluous braces around string cst as in
5648      char x[] = {"foo"}; */
5649   if (string_flag
5650       && constructor_type
5651       && TREE_CODE (constructor_type) == ARRAY_TYPE
5652       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
5653       && integer_zerop (constructor_unfilled_index))
5654     {
5655       if (constructor_stack->replacement_value)
5656         error_init ("excess elements in char array initializer");
5657       constructor_stack->replacement_value = value;
5658       return;
5659     }
5660
5661   if (constructor_stack->replacement_value != 0)
5662     {
5663       error_init ("excess elements in struct initializer");
5664       return;
5665     }
5666
5667   /* Ignore elements of a brace group if it is entirely superfluous
5668      and has already been diagnosed.  */
5669   if (constructor_type == 0)
5670     return;
5671
5672   /* If we've exhausted any levels that didn't have braces,
5673      pop them now.  */
5674   while (constructor_stack->implicit)
5675     {
5676       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5677            || TREE_CODE (constructor_type) == UNION_TYPE)
5678           && constructor_fields == 0)
5679         process_init_element (pop_init_level (1));
5680       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5681                && (constructor_max_index == 0
5682                    || tree_int_cst_lt (constructor_max_index,
5683                                        constructor_index)))
5684         process_init_element (pop_init_level (1));
5685       else
5686         break;
5687     }
5688
5689   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
5690   if (constructor_range_stack)
5691     {
5692       /* If value is a compound literal and we'll be just using its
5693          content, don't put it into a SAVE_EXPR.  */
5694       if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
5695           || !require_constant_value
5696           || flag_isoc99)
5697         value = save_expr (value);
5698     }
5699
5700   while (1)
5701     {
5702       if (TREE_CODE (constructor_type) == RECORD_TYPE)
5703         {
5704           tree fieldtype;
5705           enum tree_code fieldcode;
5706
5707           if (constructor_fields == 0)
5708             {
5709               pedwarn_init ("excess elements in struct initializer");
5710               break;
5711             }
5712
5713           fieldtype = TREE_TYPE (constructor_fields);
5714           if (fieldtype != error_mark_node)
5715             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5716           fieldcode = TREE_CODE (fieldtype);
5717
5718           /* Error for non-static initialization of a flexible array member.  */
5719           if (fieldcode == ARRAY_TYPE
5720               && !require_constant_value
5721               && TYPE_SIZE (fieldtype) == NULL_TREE
5722               && TREE_CHAIN (constructor_fields) == NULL_TREE)
5723             {
5724               error_init ("non-static initialization of a flexible array member");
5725               break;
5726             }
5727
5728           /* Accept a string constant to initialize a subarray.  */
5729           if (value != 0
5730               && fieldcode == ARRAY_TYPE
5731               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5732               && string_flag)
5733             value = orig_value;
5734           /* Otherwise, if we have come to a subaggregate,
5735              and we don't have an element of its type, push into it.  */
5736           else if (value != 0 && !constructor_no_implicit
5737                    && value != error_mark_node
5738                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5739                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5740                        || fieldcode == UNION_TYPE))
5741             {
5742               push_init_level (1);
5743               continue;
5744             }
5745
5746           if (value)
5747             {
5748               push_member_name (constructor_fields);
5749               output_init_element (value, fieldtype, constructor_fields, 1);
5750               RESTORE_SPELLING_DEPTH (constructor_depth);
5751             }
5752           else
5753             /* Do the bookkeeping for an element that was
5754                directly output as a constructor.  */
5755             {
5756               /* For a record, keep track of end position of last field.  */
5757               if (DECL_SIZE (constructor_fields))
5758                 constructor_bit_index
5759                   = size_binop (PLUS_EXPR,
5760                                 bit_position (constructor_fields),
5761                                 DECL_SIZE (constructor_fields));
5762
5763               /* If the current field was the first one not yet written out,
5764                  it isn't now, so update.  */
5765               if (constructor_unfilled_fields == constructor_fields)
5766                 {
5767                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5768                   /* Skip any nameless bit fields.  */
5769                   while (constructor_unfilled_fields != 0
5770                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5771                          && DECL_NAME (constructor_unfilled_fields) == 0)
5772                     constructor_unfilled_fields =
5773                       TREE_CHAIN (constructor_unfilled_fields);
5774                 }
5775             }
5776
5777           constructor_fields = TREE_CHAIN (constructor_fields);
5778           /* Skip any nameless bit fields at the beginning.  */
5779           while (constructor_fields != 0
5780                  && DECL_C_BIT_FIELD (constructor_fields)
5781                  && DECL_NAME (constructor_fields) == 0)
5782             constructor_fields = TREE_CHAIN (constructor_fields);
5783         }
5784       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5785         {
5786           tree fieldtype;
5787           enum tree_code fieldcode;
5788
5789           if (constructor_fields == 0)
5790             {
5791               pedwarn_init ("excess elements in union initializer");
5792               break;
5793             }
5794
5795           fieldtype = TREE_TYPE (constructor_fields);
5796           if (fieldtype != error_mark_node)
5797             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5798           fieldcode = TREE_CODE (fieldtype);
5799
5800           /* Warn that traditional C rejects initialization of unions.
5801              We skip the warning if the value is zero.  This is done
5802              under the assumption that the zero initializer in user
5803              code appears conditioned on e.g. __STDC__ to avoid
5804              "missing initializer" warnings and relies on default
5805              initialization to zero in the traditional C case.
5806              We also skip the warning if the initializer is designated,
5807              again on the assumption that this must be conditional on
5808              __STDC__ anyway (and we've already complained about the
5809              member-designator already).  */
5810           if (warn_traditional && !in_system_header && !constructor_designated
5811               && !(value && (integer_zerop (value) || real_zerop (value))))
5812             warning ("traditional C rejects initialization of unions");
5813
5814           /* Accept a string constant to initialize a subarray.  */
5815           if (value != 0
5816               && fieldcode == ARRAY_TYPE
5817               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5818               && string_flag)
5819             value = orig_value;
5820           /* Otherwise, if we have come to a subaggregate,
5821              and we don't have an element of its type, push into it.  */
5822           else if (value != 0 && !constructor_no_implicit
5823                    && value != error_mark_node
5824                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5825                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5826                        || fieldcode == UNION_TYPE))
5827             {
5828               push_init_level (1);
5829               continue;
5830             }
5831
5832           if (value)
5833             {
5834               push_member_name (constructor_fields);
5835               output_init_element (value, fieldtype, constructor_fields, 1);
5836               RESTORE_SPELLING_DEPTH (constructor_depth);
5837             }
5838           else
5839             /* Do the bookkeeping for an element that was
5840                directly output as a constructor.  */
5841             {
5842               constructor_bit_index = DECL_SIZE (constructor_fields);
5843               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5844             }
5845
5846           constructor_fields = 0;
5847         }
5848       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5849         {
5850           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5851           enum tree_code eltcode = TREE_CODE (elttype);
5852
5853           /* Accept a string constant to initialize a subarray.  */
5854           if (value != 0
5855               && eltcode == ARRAY_TYPE
5856               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
5857               && string_flag)
5858             value = orig_value;
5859           /* Otherwise, if we have come to a subaggregate,
5860              and we don't have an element of its type, push into it.  */
5861           else if (value != 0 && !constructor_no_implicit
5862                    && value != error_mark_node
5863                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
5864                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
5865                        || eltcode == UNION_TYPE))
5866             {
5867               push_init_level (1);
5868               continue;
5869             }
5870
5871           if (constructor_max_index != 0
5872               && (tree_int_cst_lt (constructor_max_index, constructor_index)
5873                   || integer_all_onesp (constructor_max_index)))
5874             {
5875               pedwarn_init ("excess elements in array initializer");
5876               break;
5877             }
5878
5879           /* Now output the actual element.  */
5880           if (value)
5881             {
5882               push_array_bounds (tree_low_cst (constructor_index, 0));
5883               output_init_element (value, elttype, constructor_index, 1);
5884               RESTORE_SPELLING_DEPTH (constructor_depth);
5885             }
5886
5887           constructor_index
5888             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
5889
5890           if (! value)
5891             /* If we are doing the bookkeeping for an element that was
5892                directly output as a constructor, we must update
5893                constructor_unfilled_index.  */
5894             constructor_unfilled_index = constructor_index;
5895         }
5896       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5897         {
5898           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5899
5900          /* Do a basic check of initializer size.  Note that vectors
5901             always have a fixed size derived from their type.  */
5902           if (tree_int_cst_lt (constructor_max_index, constructor_index))
5903             {
5904               pedwarn_init ("excess elements in vector initializer");
5905               break;
5906             }
5907
5908           /* Now output the actual element.  */
5909           if (value)
5910             output_init_element (value, elttype, constructor_index, 1);
5911
5912           constructor_index
5913             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
5914
5915           if (! value)
5916             /* If we are doing the bookkeeping for an element that was
5917                directly output as a constructor, we must update
5918                constructor_unfilled_index.  */
5919             constructor_unfilled_index = constructor_index;
5920         }
5921
5922       /* Handle the sole element allowed in a braced initializer
5923          for a scalar variable.  */
5924       else if (constructor_fields == 0)
5925         {
5926           pedwarn_init ("excess elements in scalar initializer");
5927           break;
5928         }
5929       else
5930         {
5931           if (value)
5932             output_init_element (value, constructor_type, NULL_TREE, 1);
5933           constructor_fields = 0;
5934         }
5935
5936       /* Handle range initializers either at this level or anywhere higher
5937          in the designator stack.  */
5938       if (constructor_range_stack)
5939         {
5940           struct constructor_range_stack *p, *range_stack;
5941           int finish = 0;
5942
5943           range_stack = constructor_range_stack;
5944           constructor_range_stack = 0;
5945           while (constructor_stack != range_stack->stack)
5946             {
5947               if (!constructor_stack->implicit)
5948                 abort ();
5949               process_init_element (pop_init_level (1));
5950             }
5951           for (p = range_stack;
5952                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
5953                p = p->prev)
5954             {
5955               if (!constructor_stack->implicit)
5956                 abort ();
5957               process_init_element (pop_init_level (1));
5958             }
5959
5960           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
5961           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
5962             finish = 1;
5963
5964           while (1)
5965             {
5966               constructor_index = p->index;
5967               constructor_fields = p->fields;
5968               if (finish && p->range_end && p->index == p->range_start)
5969                 {
5970                   finish = 0;
5971                   p->prev = 0;
5972                 }
5973               p = p->next;
5974               if (!p)
5975                 break;
5976               push_init_level (2);
5977               p->stack = constructor_stack;
5978               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
5979                 p->index = p->range_start;
5980             }
5981
5982           if (!finish)
5983             constructor_range_stack = range_stack;
5984           continue;
5985         }
5986
5987       break;
5988     }
5989
5990   constructor_range_stack = 0;
5991 }
5992 \f
5993 /* Build a simple asm-statement, from one string literal.  */
5994 tree
5995 simple_asm_stmt (tree expr)
5996 {
5997   STRIP_NOPS (expr);
5998
5999   if (TREE_CODE (expr) == ADDR_EXPR)
6000     expr = TREE_OPERAND (expr, 0);
6001
6002   if (TREE_CODE (expr) == STRING_CST)
6003     {
6004       tree stmt;
6005
6006       /* Simple asm statements are treated as volatile.  */
6007       stmt = add_stmt (build_stmt (ASM_STMT, ridpointers[(int) RID_VOLATILE],
6008                                    expr, NULL_TREE, NULL_TREE, NULL_TREE));
6009       ASM_INPUT_P (stmt) = 1;
6010       return stmt;
6011     }
6012
6013   error ("argument of `asm' is not a constant string");
6014   return NULL_TREE;
6015 }
6016
6017 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6018    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6019
6020 tree
6021 build_asm_stmt (tree cv_qualifier, tree string, tree outputs, tree inputs,
6022                 tree clobbers)
6023 {
6024   tree tail;
6025
6026   if (TREE_CODE (string) != STRING_CST)
6027     {
6028       error ("asm template is not a string constant");
6029       return NULL_TREE;
6030     }
6031
6032   if (cv_qualifier != NULL_TREE
6033       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6034     {
6035       warning ("%s qualifier ignored on asm",
6036                IDENTIFIER_POINTER (cv_qualifier));
6037       cv_qualifier = NULL_TREE;
6038     }
6039
6040   /* We can remove output conversions that change the type,
6041      but not the mode.  */
6042   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6043     {
6044       tree output = TREE_VALUE (tail);
6045
6046       STRIP_NOPS (output);
6047       TREE_VALUE (tail) = output;
6048
6049       /* Allow conversions as LHS here.  build_modify_expr as called below
6050          will do the right thing with them.  */
6051       while (TREE_CODE (output) == NOP_EXPR
6052              || TREE_CODE (output) == CONVERT_EXPR
6053              || TREE_CODE (output) == FLOAT_EXPR
6054              || TREE_CODE (output) == FIX_TRUNC_EXPR
6055              || TREE_CODE (output) == FIX_FLOOR_EXPR
6056              || TREE_CODE (output) == FIX_ROUND_EXPR
6057              || TREE_CODE (output) == FIX_CEIL_EXPR)
6058         output = TREE_OPERAND (output, 0);
6059
6060       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6061     }
6062
6063   /* Remove output conversions that change the type but not the mode.  */
6064   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6065     {
6066       tree output = TREE_VALUE (tail);
6067       STRIP_NOPS (output);
6068       TREE_VALUE (tail) = output;
6069     }
6070
6071   /* Perform default conversions on array and function inputs.
6072      Don't do this for other types as it would screw up operands
6073      expected to be in memory.  */
6074   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6075     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6076
6077   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6078                                outputs, inputs, clobbers));
6079 }
6080
6081 /* Expand an ASM statement with operands, handling output operands
6082    that are not variables or INDIRECT_REFS by transforming such
6083    cases into cases that expand_asm_operands can handle.
6084
6085    Arguments are same as for expand_asm_operands.  */
6086
6087 void
6088 c_expand_asm_operands (tree string, tree outputs, tree inputs,
6089                        tree clobbers, int vol, location_t locus)
6090 {
6091   int noutputs = list_length (outputs);
6092   int i;
6093   /* o[I] is the place that output number I should be written.  */
6094   tree *o = alloca (noutputs * sizeof (tree));
6095   tree tail;
6096
6097   /* Record the contents of OUTPUTS before it is modified.  */
6098   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6099     {
6100       o[i] = TREE_VALUE (tail);
6101       if (o[i] == error_mark_node)
6102         return;
6103     }
6104
6105   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6106      OUTPUTS some trees for where the values were actually stored.  */
6107   expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
6108
6109   /* Copy all the intermediate outputs into the specified outputs.  */
6110   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6111     {
6112       if (o[i] != TREE_VALUE (tail))
6113         {
6114           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6115                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6116           free_temp_slots ();
6117
6118           /* Restore the original value so that it's correct the next
6119              time we expand this function.  */
6120           TREE_VALUE (tail) = o[i];
6121         }
6122       /* Detect modification of read-only values.
6123          (Otherwise done by build_modify_expr.)  */
6124       else
6125         {
6126           tree type = TREE_TYPE (o[i]);
6127           if (TREE_READONLY (o[i])
6128               || TYPE_READONLY (type)
6129               || ((TREE_CODE (type) == RECORD_TYPE
6130                    || TREE_CODE (type) == UNION_TYPE)
6131                   && C_TYPE_FIELDS_READONLY (type)))
6132             readonly_warning (o[i], "modification by `asm'");
6133         }
6134     }
6135
6136   /* Those MODIFY_EXPRs could do autoincrements.  */
6137   emit_queue ();
6138 }
6139 \f
6140 /* Expand a C `return' statement.
6141    RETVAL is the expression for what to return,
6142    or a null pointer for `return;' with no value.  */
6143
6144 tree
6145 c_expand_return (tree retval)
6146 {
6147   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6148
6149   if (TREE_THIS_VOLATILE (current_function_decl))
6150     warning ("function declared `noreturn' has a `return' statement");
6151
6152   if (!retval)
6153     {
6154       current_function_returns_null = 1;
6155       if ((warn_return_type || flag_isoc99)
6156           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6157         pedwarn_c99 ("`return' with no value, in function returning non-void");
6158     }
6159   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6160     {
6161       current_function_returns_null = 1;
6162       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6163         pedwarn ("`return' with a value, in function returning void");
6164     }
6165   else
6166     {
6167       tree t = convert_for_assignment (valtype, retval, _("return"),
6168                                        NULL_TREE, NULL_TREE, 0);
6169       tree res = DECL_RESULT (current_function_decl);
6170       tree inner;
6171
6172       current_function_returns_value = 1;
6173       if (t == error_mark_node)
6174         return NULL_TREE;
6175
6176       inner = t = convert (TREE_TYPE (res), t);
6177
6178       /* Strip any conversions, additions, and subtractions, and see if
6179          we are returning the address of a local variable.  Warn if so.  */
6180       while (1)
6181         {
6182           switch (TREE_CODE (inner))
6183             {
6184             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6185             case PLUS_EXPR:
6186               inner = TREE_OPERAND (inner, 0);
6187               continue;
6188
6189             case MINUS_EXPR:
6190               /* If the second operand of the MINUS_EXPR has a pointer
6191                  type (or is converted from it), this may be valid, so
6192                  don't give a warning.  */
6193               {
6194                 tree op1 = TREE_OPERAND (inner, 1);
6195
6196                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6197                        && (TREE_CODE (op1) == NOP_EXPR
6198                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6199                            || TREE_CODE (op1) == CONVERT_EXPR))
6200                   op1 = TREE_OPERAND (op1, 0);
6201
6202                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6203                   break;
6204
6205                 inner = TREE_OPERAND (inner, 0);
6206                 continue;
6207               }
6208
6209             case ADDR_EXPR:
6210               inner = TREE_OPERAND (inner, 0);
6211
6212               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6213                 inner = TREE_OPERAND (inner, 0);
6214
6215               if (TREE_CODE (inner) == VAR_DECL
6216                   && ! DECL_EXTERNAL (inner)
6217                   && ! TREE_STATIC (inner)
6218                   && DECL_CONTEXT (inner) == current_function_decl)
6219                 warning ("function returns address of local variable");
6220               break;
6221
6222             default:
6223               break;
6224             }
6225
6226           break;
6227         }
6228
6229       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6230     }
6231
6232  return add_stmt (build_return_stmt (retval));
6233 }
6234 \f
6235 struct c_switch {
6236   /* The SWITCH_STMT being built.  */
6237   tree switch_stmt;
6238   /* A splay-tree mapping the low element of a case range to the high
6239      element, or NULL_TREE if there is no high element.  Used to
6240      determine whether or not a new case label duplicates an old case
6241      label.  We need a tree, rather than simply a hash table, because
6242      of the GNU case range extension.  */
6243   splay_tree cases;
6244   /* The next node on the stack.  */
6245   struct c_switch *next;
6246 };
6247
6248 /* A stack of the currently active switch statements.  The innermost
6249    switch statement is on the top of the stack.  There is no need to
6250    mark the stack for garbage collection because it is only active
6251    during the processing of the body of a function, and we never
6252    collect at that point.  */
6253
6254 static struct c_switch *switch_stack;
6255
6256 /* Start a C switch statement, testing expression EXP.  Return the new
6257    SWITCH_STMT.  */
6258
6259 tree
6260 c_start_case (tree exp)
6261 {
6262   enum tree_code code;
6263   tree type, orig_type = error_mark_node;
6264   struct c_switch *cs;
6265
6266   if (exp != error_mark_node)
6267     {
6268       code = TREE_CODE (TREE_TYPE (exp));
6269       orig_type = TREE_TYPE (exp);
6270
6271       if (! INTEGRAL_TYPE_P (orig_type)
6272           && code != ERROR_MARK)
6273         {
6274           error ("switch quantity not an integer");
6275           exp = integer_zero_node;
6276         }
6277       else
6278         {
6279           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6280
6281           if (warn_traditional && !in_system_header
6282               && (type == long_integer_type_node
6283                   || type == long_unsigned_type_node))
6284             warning ("`long' switch expression not converted to `int' in ISO C");
6285
6286           exp = default_conversion (exp);
6287           type = TREE_TYPE (exp);
6288         }
6289     }
6290
6291   /* Add this new SWITCH_STMT to the stack.  */
6292   cs = xmalloc (sizeof (*cs));
6293   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
6294   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6295   cs->next = switch_stack;
6296   switch_stack = cs;
6297
6298   return add_stmt (switch_stack->switch_stmt);
6299 }
6300
6301 /* Process a case label.  */
6302
6303 tree
6304 do_case (tree low_value, tree high_value)
6305 {
6306   tree label = NULL_TREE;
6307
6308   if (switch_stack)
6309     {
6310       bool switch_was_empty_p = (SWITCH_BODY (switch_stack->switch_stmt) == NULL_TREE);
6311
6312       label = c_add_case_label (switch_stack->cases,
6313                                 SWITCH_COND (switch_stack->switch_stmt),
6314                                 low_value, high_value);
6315       if (label == error_mark_node)
6316         label = NULL_TREE;
6317       else if (switch_was_empty_p)
6318         {
6319           /* Attach the first case label to the SWITCH_BODY.  */
6320           SWITCH_BODY (switch_stack->switch_stmt) = TREE_CHAIN (switch_stack->switch_stmt);
6321           TREE_CHAIN (switch_stack->switch_stmt) = NULL_TREE;
6322         }
6323     }
6324   else if (low_value)
6325     error ("case label not within a switch statement");
6326   else
6327     error ("`default' label not within a switch statement");
6328
6329   return label;
6330 }
6331
6332 /* Finish the switch statement.  */
6333
6334 void
6335 c_finish_case (void)
6336 {
6337   struct c_switch *cs = switch_stack;
6338
6339   /* Rechain the next statements to the SWITCH_STMT.  */
6340   last_tree = cs->switch_stmt;
6341
6342   /* Pop the stack.  */
6343   switch_stack = switch_stack->next;
6344   splay_tree_delete (cs->cases);
6345   free (cs);
6346 }
6347
6348 /* Build a binary-operation expression without default conversions.
6349    CODE is the kind of expression to build.
6350    This function differs from `build' in several ways:
6351    the data type of the result is computed and recorded in it,
6352    warnings are generated if arg data types are invalid,
6353    special handling for addition and subtraction of pointers is known,
6354    and some optimization is done (operations on narrow ints
6355    are done in the narrower type when that gives the same result).
6356    Constant folding is also done before the result is returned.
6357
6358    Note that the operands will never have enumeral types, or function
6359    or array types, because either they will have the default conversions
6360    performed or they have both just been converted to some other type in which
6361    the arithmetic is to be done.  */
6362
6363 tree
6364 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6365                  int convert_p)
6366 {
6367   tree type0, type1;
6368   enum tree_code code0, code1;
6369   tree op0, op1;
6370
6371   /* Expression code to give to the expression when it is built.
6372      Normally this is CODE, which is what the caller asked for,
6373      but in some special cases we change it.  */
6374   enum tree_code resultcode = code;
6375
6376   /* Data type in which the computation is to be performed.
6377      In the simplest cases this is the common type of the arguments.  */
6378   tree result_type = NULL;
6379
6380   /* Nonzero means operands have already been type-converted
6381      in whatever way is necessary.
6382      Zero means they need to be converted to RESULT_TYPE.  */
6383   int converted = 0;
6384
6385   /* Nonzero means create the expression with this type, rather than
6386      RESULT_TYPE.  */
6387   tree build_type = 0;
6388
6389   /* Nonzero means after finally constructing the expression
6390      convert it to this type.  */
6391   tree final_type = 0;
6392
6393   /* Nonzero if this is an operation like MIN or MAX which can
6394      safely be computed in short if both args are promoted shorts.
6395      Also implies COMMON.
6396      -1 indicates a bitwise operation; this makes a difference
6397      in the exact conditions for when it is safe to do the operation
6398      in a narrower mode.  */
6399   int shorten = 0;
6400
6401   /* Nonzero if this is a comparison operation;
6402      if both args are promoted shorts, compare the original shorts.
6403      Also implies COMMON.  */
6404   int short_compare = 0;
6405
6406   /* Nonzero if this is a right-shift operation, which can be computed on the
6407      original short and then promoted if the operand is a promoted short.  */
6408   int short_shift = 0;
6409
6410   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
6411   int common = 0;
6412
6413   if (convert_p)
6414     {
6415       op0 = default_conversion (orig_op0);
6416       op1 = default_conversion (orig_op1);
6417     }
6418   else
6419     {
6420       op0 = orig_op0;
6421       op1 = orig_op1;
6422     }
6423
6424   type0 = TREE_TYPE (op0);
6425   type1 = TREE_TYPE (op1);
6426
6427   /* The expression codes of the data types of the arguments tell us
6428      whether the arguments are integers, floating, pointers, etc.  */
6429   code0 = TREE_CODE (type0);
6430   code1 = TREE_CODE (type1);
6431
6432   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
6433   STRIP_TYPE_NOPS (op0);
6434   STRIP_TYPE_NOPS (op1);
6435
6436   /* If an error was already reported for one of the arguments,
6437      avoid reporting another error.  */
6438
6439   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6440     return error_mark_node;
6441
6442   switch (code)
6443     {
6444     case PLUS_EXPR:
6445       /* Handle the pointer + int case.  */
6446       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6447         return pointer_int_sum (PLUS_EXPR, op0, op1);
6448       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6449         return pointer_int_sum (PLUS_EXPR, op1, op0);
6450       else
6451         common = 1;
6452       break;
6453
6454     case MINUS_EXPR:
6455       /* Subtraction of two similar pointers.
6456          We must subtract them as integers, then divide by object size.  */
6457       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6458           && comp_target_types (type0, type1, 1))
6459         return pointer_diff (op0, op1);
6460       /* Handle pointer minus int.  Just like pointer plus int.  */
6461       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6462         return pointer_int_sum (MINUS_EXPR, op0, op1);
6463       else
6464         common = 1;
6465       break;
6466
6467     case MULT_EXPR:
6468       common = 1;
6469       break;
6470
6471     case TRUNC_DIV_EXPR:
6472     case CEIL_DIV_EXPR:
6473     case FLOOR_DIV_EXPR:
6474     case ROUND_DIV_EXPR:
6475     case EXACT_DIV_EXPR:
6476       /* Floating point division by zero is a legitimate way to obtain
6477          infinities and NaNs.  */
6478       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6479         warning ("division by zero");
6480
6481       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6482            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6483           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6484               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6485         {
6486           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6487             resultcode = RDIV_EXPR;
6488           else
6489             /* Although it would be tempting to shorten always here, that
6490                loses on some targets, since the modulo instruction is
6491                undefined if the quotient can't be represented in the
6492                computation mode.  We shorten only if unsigned or if
6493                dividing by something we know != -1.  */
6494             shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6495                        || (TREE_CODE (op1) == INTEGER_CST
6496                            && ! integer_all_onesp (op1)));
6497           common = 1;
6498         }
6499       break;
6500
6501     case BIT_AND_EXPR:
6502     case BIT_IOR_EXPR:
6503     case BIT_XOR_EXPR:
6504       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6505         shorten = -1;
6506       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
6507         common = 1;
6508       break;
6509
6510     case TRUNC_MOD_EXPR:
6511     case FLOOR_MOD_EXPR:
6512       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6513         warning ("division by zero");
6514
6515       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6516         {
6517           /* Although it would be tempting to shorten always here, that loses
6518              on some targets, since the modulo instruction is undefined if the
6519              quotient can't be represented in the computation mode.  We shorten
6520              only if unsigned or if dividing by something we know != -1.  */
6521           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6522                      || (TREE_CODE (op1) == INTEGER_CST
6523                          && ! integer_all_onesp (op1)));
6524           common = 1;
6525         }
6526       break;
6527
6528     case TRUTH_ANDIF_EXPR:
6529     case TRUTH_ORIF_EXPR:
6530     case TRUTH_AND_EXPR:
6531     case TRUTH_OR_EXPR:
6532     case TRUTH_XOR_EXPR:
6533       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
6534            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
6535           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
6536               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
6537         {
6538           /* Result of these operations is always an int,
6539              but that does not mean the operands should be
6540              converted to ints!  */
6541           result_type = integer_type_node;
6542           op0 = c_common_truthvalue_conversion (op0);
6543           op1 = c_common_truthvalue_conversion (op1);
6544           converted = 1;
6545         }
6546       break;
6547
6548       /* Shift operations: result has same type as first operand;
6549          always convert second operand to int.
6550          Also set SHORT_SHIFT if shifting rightward.  */
6551
6552     case RSHIFT_EXPR:
6553       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6554         {
6555           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6556             {
6557               if (tree_int_cst_sgn (op1) < 0)
6558                 warning ("right shift count is negative");
6559               else
6560                 {
6561                   if (! integer_zerop (op1))
6562                     short_shift = 1;
6563
6564                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6565                     warning ("right shift count >= width of type");
6566                 }
6567             }
6568
6569           /* Use the type of the value to be shifted.  */
6570           result_type = type0;
6571           /* Convert the shift-count to an integer, regardless of size
6572              of value being shifted.  */
6573           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6574             op1 = convert (integer_type_node, op1);
6575           /* Avoid converting op1 to result_type later.  */
6576           converted = 1;
6577         }
6578       break;
6579
6580     case LSHIFT_EXPR:
6581       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6582         {
6583           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6584             {
6585               if (tree_int_cst_sgn (op1) < 0)
6586                 warning ("left shift count is negative");
6587
6588               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6589                 warning ("left shift count >= width of type");
6590             }
6591
6592           /* Use the type of the value to be shifted.  */
6593           result_type = type0;
6594           /* Convert the shift-count to an integer, regardless of size
6595              of value being shifted.  */
6596           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6597             op1 = convert (integer_type_node, op1);
6598           /* Avoid converting op1 to result_type later.  */
6599           converted = 1;
6600         }
6601       break;
6602
6603     case RROTATE_EXPR:
6604     case LROTATE_EXPR:
6605       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6606         {
6607           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6608             {
6609               if (tree_int_cst_sgn (op1) < 0)
6610                 warning ("shift count is negative");
6611               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6612                 warning ("shift count >= width of type");
6613             }
6614
6615           /* Use the type of the value to be shifted.  */
6616           result_type = type0;
6617           /* Convert the shift-count to an integer, regardless of size
6618              of value being shifted.  */
6619           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6620             op1 = convert (integer_type_node, op1);
6621           /* Avoid converting op1 to result_type later.  */
6622           converted = 1;
6623         }
6624       break;
6625
6626     case EQ_EXPR:
6627     case NE_EXPR:
6628       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
6629         warning ("comparing floating point with == or != is unsafe");
6630       /* Result of comparison is always int,
6631          but don't convert the args to int!  */
6632       build_type = integer_type_node;
6633       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6634            || code0 == COMPLEX_TYPE
6635            || code0 == VECTOR_TYPE)
6636           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6637               || code1 == COMPLEX_TYPE
6638               || code1 == VECTOR_TYPE))
6639         short_compare = 1;
6640       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6641         {
6642           tree tt0 = TREE_TYPE (type0);
6643           tree tt1 = TREE_TYPE (type1);
6644           /* Anything compares with void *.  void * compares with anything.
6645              Otherwise, the targets must be compatible
6646              and both must be object or both incomplete.  */
6647           if (comp_target_types (type0, type1, 1))
6648             result_type = common_type (type0, type1);
6649           else if (VOID_TYPE_P (tt0))
6650             {
6651               /* op0 != orig_op0 detects the case of something
6652                  whose value is 0 but which isn't a valid null ptr const.  */
6653               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
6654                   && TREE_CODE (tt1) == FUNCTION_TYPE)
6655                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6656             }
6657           else if (VOID_TYPE_P (tt1))
6658             {
6659               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
6660                   && TREE_CODE (tt0) == FUNCTION_TYPE)
6661                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6662             }
6663           else
6664             pedwarn ("comparison of distinct pointer types lacks a cast");
6665
6666           if (result_type == NULL_TREE)
6667             result_type = ptr_type_node;
6668         }
6669       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6670                && integer_zerop (op1))
6671         result_type = type0;
6672       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6673                && integer_zerop (op0))
6674         result_type = type1;
6675       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6676         {
6677           result_type = type0;
6678           pedwarn ("comparison between pointer and integer");
6679         }
6680       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6681         {
6682           result_type = type1;
6683           pedwarn ("comparison between pointer and integer");
6684         }
6685       break;
6686
6687     case MAX_EXPR:
6688     case MIN_EXPR:
6689       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6690           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6691         shorten = 1;
6692       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6693         {
6694           if (comp_target_types (type0, type1, 1))
6695             {
6696               result_type = common_type (type0, type1);
6697               if (pedantic
6698                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6699                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6700             }
6701           else
6702             {
6703               result_type = ptr_type_node;
6704               pedwarn ("comparison of distinct pointer types lacks a cast");
6705             }
6706         }
6707       break;
6708
6709     case LE_EXPR:
6710     case GE_EXPR:
6711     case LT_EXPR:
6712     case GT_EXPR:
6713       build_type = integer_type_node;
6714       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6715           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6716         short_compare = 1;
6717       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6718         {
6719           if (comp_target_types (type0, type1, 1))
6720             {
6721               result_type = common_type (type0, type1);
6722               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
6723                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
6724                 pedwarn ("comparison of complete and incomplete pointers");
6725               else if (pedantic
6726                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6727                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6728             }
6729           else
6730             {
6731               result_type = ptr_type_node;
6732               pedwarn ("comparison of distinct pointer types lacks a cast");
6733             }
6734         }
6735       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6736                && integer_zerop (op1))
6737         {
6738           result_type = type0;
6739           if (pedantic || extra_warnings)
6740             pedwarn ("ordered comparison of pointer with integer zero");
6741         }
6742       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6743                && integer_zerop (op0))
6744         {
6745           result_type = type1;
6746           if (pedantic)
6747             pedwarn ("ordered comparison of pointer with integer zero");
6748         }
6749       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6750         {
6751           result_type = type0;
6752           pedwarn ("comparison between pointer and integer");
6753         }
6754       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6755         {
6756           result_type = type1;
6757           pedwarn ("comparison between pointer and integer");
6758         }
6759       break;
6760
6761     case UNORDERED_EXPR:
6762     case ORDERED_EXPR:
6763     case UNLT_EXPR:
6764     case UNLE_EXPR:
6765     case UNGT_EXPR:
6766     case UNGE_EXPR:
6767     case UNEQ_EXPR:
6768       build_type = integer_type_node;
6769       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
6770         {
6771           error ("unordered comparison on non-floating point argument");
6772           return error_mark_node;
6773         }
6774       common = 1;
6775       break;
6776
6777     default:
6778       break;
6779     }
6780
6781   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
6782        || code0 == VECTOR_TYPE)
6783       &&
6784       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
6785        || code1 == VECTOR_TYPE))
6786     {
6787       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
6788
6789       if (shorten || common || short_compare)
6790         result_type = common_type (type0, type1);
6791
6792       /* For certain operations (which identify themselves by shorten != 0)
6793          if both args were extended from the same smaller type,
6794          do the arithmetic in that type and then extend.
6795
6796          shorten !=0 and !=1 indicates a bitwise operation.
6797          For them, this optimization is safe only if
6798          both args are zero-extended or both are sign-extended.
6799          Otherwise, we might change the result.
6800          Eg, (short)-1 | (unsigned short)-1 is (int)-1
6801          but calculated in (unsigned short) it would be (unsigned short)-1.  */
6802
6803       if (shorten && none_complex)
6804         {
6805           int unsigned0, unsigned1;
6806           tree arg0 = get_narrower (op0, &unsigned0);
6807           tree arg1 = get_narrower (op1, &unsigned1);
6808           /* UNS is 1 if the operation to be done is an unsigned one.  */
6809           int uns = TREE_UNSIGNED (result_type);
6810           tree type;
6811
6812           final_type = result_type;
6813
6814           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
6815              but it *requires* conversion to FINAL_TYPE.  */
6816
6817           if ((TYPE_PRECISION (TREE_TYPE (op0))
6818                == TYPE_PRECISION (TREE_TYPE (arg0)))
6819               && TREE_TYPE (op0) != final_type)
6820             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
6821           if ((TYPE_PRECISION (TREE_TYPE (op1))
6822                == TYPE_PRECISION (TREE_TYPE (arg1)))
6823               && TREE_TYPE (op1) != final_type)
6824             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
6825
6826           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
6827
6828           /* For bitwise operations, signedness of nominal type
6829              does not matter.  Consider only how operands were extended.  */
6830           if (shorten == -1)
6831             uns = unsigned0;
6832
6833           /* Note that in all three cases below we refrain from optimizing
6834              an unsigned operation on sign-extended args.
6835              That would not be valid.  */
6836
6837           /* Both args variable: if both extended in same way
6838              from same width, do it in that width.
6839              Do it unsigned if args were zero-extended.  */
6840           if ((TYPE_PRECISION (TREE_TYPE (arg0))
6841                < TYPE_PRECISION (result_type))
6842               && (TYPE_PRECISION (TREE_TYPE (arg1))
6843                   == TYPE_PRECISION (TREE_TYPE (arg0)))
6844               && unsigned0 == unsigned1
6845               && (unsigned0 || !uns))
6846             result_type
6847               = c_common_signed_or_unsigned_type
6848               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
6849           else if (TREE_CODE (arg0) == INTEGER_CST
6850                    && (unsigned1 || !uns)
6851                    && (TYPE_PRECISION (TREE_TYPE (arg1))
6852                        < TYPE_PRECISION (result_type))
6853                    && (type
6854                        = c_common_signed_or_unsigned_type (unsigned1,
6855                                                            TREE_TYPE (arg1)),
6856                        int_fits_type_p (arg0, type)))
6857             result_type = type;
6858           else if (TREE_CODE (arg1) == INTEGER_CST
6859                    && (unsigned0 || !uns)
6860                    && (TYPE_PRECISION (TREE_TYPE (arg0))
6861                        < TYPE_PRECISION (result_type))
6862                    && (type
6863                        = c_common_signed_or_unsigned_type (unsigned0,
6864                                                            TREE_TYPE (arg0)),
6865                        int_fits_type_p (arg1, type)))
6866             result_type = type;
6867         }
6868
6869       /* Shifts can be shortened if shifting right.  */
6870
6871       if (short_shift)
6872         {
6873           int unsigned_arg;
6874           tree arg0 = get_narrower (op0, &unsigned_arg);
6875
6876           final_type = result_type;
6877
6878           if (arg0 == op0 && final_type == TREE_TYPE (op0))
6879             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
6880
6881           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
6882               /* We can shorten only if the shift count is less than the
6883                  number of bits in the smaller type size.  */
6884               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
6885               /* We cannot drop an unsigned shift after sign-extension.  */
6886               && (!TREE_UNSIGNED (final_type) || unsigned_arg))
6887             {
6888               /* Do an unsigned shift if the operand was zero-extended.  */
6889               result_type
6890                 = c_common_signed_or_unsigned_type (unsigned_arg,
6891                                                     TREE_TYPE (arg0));
6892               /* Convert value-to-be-shifted to that type.  */
6893               if (TREE_TYPE (op0) != result_type)
6894                 op0 = convert (result_type, op0);
6895               converted = 1;
6896             }
6897         }
6898
6899       /* Comparison operations are shortened too but differently.
6900          They identify themselves by setting short_compare = 1.  */
6901
6902       if (short_compare)
6903         {
6904           /* Don't write &op0, etc., because that would prevent op0
6905              from being kept in a register.
6906              Instead, make copies of the our local variables and
6907              pass the copies by reference, then copy them back afterward.  */
6908           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
6909           enum tree_code xresultcode = resultcode;
6910           tree val
6911             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
6912
6913           if (val != 0)
6914             return val;
6915
6916           op0 = xop0, op1 = xop1;
6917           converted = 1;
6918           resultcode = xresultcode;
6919
6920           if (warn_sign_compare && skip_evaluation == 0)
6921             {
6922               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
6923               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
6924               int unsignedp0, unsignedp1;
6925               tree primop0 = get_narrower (op0, &unsignedp0);
6926               tree primop1 = get_narrower (op1, &unsignedp1);
6927
6928               xop0 = orig_op0;
6929               xop1 = orig_op1;
6930               STRIP_TYPE_NOPS (xop0);
6931               STRIP_TYPE_NOPS (xop1);
6932
6933               /* Give warnings for comparisons between signed and unsigned
6934                  quantities that may fail.
6935
6936                  Do the checking based on the original operand trees, so that
6937                  casts will be considered, but default promotions won't be.
6938
6939                  Do not warn if the comparison is being done in a signed type,
6940                  since the signed type will only be chosen if it can represent
6941                  all the values of the unsigned type.  */
6942               if (! TREE_UNSIGNED (result_type))
6943                 /* OK */;
6944               /* Do not warn if both operands are the same signedness.  */
6945               else if (op0_signed == op1_signed)
6946                 /* OK */;
6947               else
6948                 {
6949                   tree sop, uop;
6950
6951                   if (op0_signed)
6952                     sop = xop0, uop = xop1;
6953                   else
6954                     sop = xop1, uop = xop0;
6955
6956                   /* Do not warn if the signed quantity is an
6957                      unsuffixed integer literal (or some static
6958                      constant expression involving such literals or a
6959                      conditional expression involving such literals)
6960                      and it is non-negative.  */
6961                   if (c_tree_expr_nonnegative_p (sop))
6962                     /* OK */;
6963                   /* Do not warn if the comparison is an equality operation,
6964                      the unsigned quantity is an integral constant, and it
6965                      would fit in the result if the result were signed.  */
6966                   else if (TREE_CODE (uop) == INTEGER_CST
6967                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
6968                            && int_fits_type_p
6969                            (uop, c_common_signed_type (result_type)))
6970                     /* OK */;
6971                   /* Do not warn if the unsigned quantity is an enumeration
6972                      constant and its maximum value would fit in the result
6973                      if the result were signed.  */
6974                   else if (TREE_CODE (uop) == INTEGER_CST
6975                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
6976                            && int_fits_type_p
6977                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
6978                             c_common_signed_type (result_type)))
6979                     /* OK */;
6980                   else
6981                     warning ("comparison between signed and unsigned");
6982                 }
6983
6984               /* Warn if two unsigned values are being compared in a size
6985                  larger than their original size, and one (and only one) is the
6986                  result of a `~' operator.  This comparison will always fail.
6987
6988                  Also warn if one operand is a constant, and the constant
6989                  does not have all bits set that are set in the ~ operand
6990                  when it is extended.  */
6991
6992               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
6993                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
6994                 {
6995                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
6996                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
6997                                             &unsignedp0);
6998                   else
6999                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7000                                             &unsignedp1);
7001
7002                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7003                     {
7004                       tree primop;
7005                       HOST_WIDE_INT constant, mask;
7006                       int unsignedp, bits;
7007
7008                       if (host_integerp (primop0, 0))
7009                         {
7010                           primop = primop1;
7011                           unsignedp = unsignedp1;
7012                           constant = tree_low_cst (primop0, 0);
7013                         }
7014                       else
7015                         {
7016                           primop = primop0;
7017                           unsignedp = unsignedp0;
7018                           constant = tree_low_cst (primop1, 0);
7019                         }
7020
7021                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7022                       if (bits < TYPE_PRECISION (result_type)
7023                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7024                         {
7025                           mask = (~ (HOST_WIDE_INT) 0) << bits;
7026                           if ((mask & constant) != mask)
7027                             warning ("comparison of promoted ~unsigned with constant");
7028                         }
7029                     }
7030                   else if (unsignedp0 && unsignedp1
7031                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7032                                < TYPE_PRECISION (result_type))
7033                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7034                                < TYPE_PRECISION (result_type)))
7035                     warning ("comparison of promoted ~unsigned with unsigned");
7036                 }
7037             }
7038         }
7039     }
7040
7041   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7042      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7043      Then the expression will be built.
7044      It will be given type FINAL_TYPE if that is nonzero;
7045      otherwise, it will be given type RESULT_TYPE.  */
7046
7047   if (!result_type)
7048     {
7049       binary_op_error (code);
7050       return error_mark_node;
7051     }
7052
7053   if (! converted)
7054     {
7055       if (TREE_TYPE (op0) != result_type)
7056         op0 = convert (result_type, op0);
7057       if (TREE_TYPE (op1) != result_type)
7058         op1 = convert (result_type, op1);
7059     }
7060
7061   if (build_type == NULL_TREE)
7062     build_type = result_type;
7063
7064   {
7065     tree result = build (resultcode, build_type, op0, op1);
7066     tree folded;
7067
7068     /* Treat expressions in initializers specially as they can't trap.  */
7069     folded = initializer_stack ? fold_initializer (result)
7070                                : fold (result);
7071     if (folded == result)
7072       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
7073     if (final_type != 0)
7074       return convert (final_type, folded);
7075     return folded;
7076   }
7077 }
7078