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   /* Quickly detect the usual case where op1 and op2 have the same type
2655      after promotion.  */
2656   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2657     {
2658       if (type1 == type2)
2659         result_type = type1;
2660       else
2661         result_type = TYPE_MAIN_VARIANT (type1);
2662     }
2663   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2664             || code1 == COMPLEX_TYPE)
2665            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2666                || code2 == COMPLEX_TYPE))
2667     {
2668       result_type = common_type (type1, type2);
2669
2670       /* If -Wsign-compare, warn here if type1 and type2 have
2671          different signedness.  We'll promote the signed to unsigned
2672          and later code won't know it used to be different.
2673          Do this check on the original types, so that explicit casts
2674          will be considered, but default promotions won't.  */
2675       if (warn_sign_compare && !skip_evaluation)
2676         {
2677           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
2678           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
2679
2680           if (unsigned_op1 ^ unsigned_op2)
2681             {
2682               /* Do not warn if the result type is signed, since the
2683                  signed type will only be chosen if it can represent
2684                  all the values of the unsigned type.  */
2685               if (! TREE_UNSIGNED (result_type))
2686                 /* OK */;
2687               /* Do not warn if the signed quantity is an unsuffixed
2688                  integer literal (or some static constant expression
2689                  involving such literals) and it is non-negative.  */
2690               else if ((unsigned_op2 && c_tree_expr_nonnegative_p (op1))
2691                        || (unsigned_op1 && c_tree_expr_nonnegative_p (op2)))
2692                 /* OK */;
2693               else
2694                 warning ("signed and unsigned type in conditional expression");
2695             }
2696         }
2697     }
2698   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2699     {
2700       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2701         pedwarn ("ISO C forbids conditional expr with only one void side");
2702       result_type = void_type_node;
2703     }
2704   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2705     {
2706       if (comp_target_types (type1, type2, 1))
2707         result_type = common_type (type1, type2);
2708       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2709                && TREE_CODE (orig_op1) != NOP_EXPR)
2710         result_type = qualify_type (type2, type1);
2711       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2712                && TREE_CODE (orig_op2) != NOP_EXPR)
2713         result_type = qualify_type (type1, type2);
2714       else if (VOID_TYPE_P (TREE_TYPE (type1)))
2715         {
2716           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2717             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2718           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2719                                                           TREE_TYPE (type2)));
2720         }
2721       else if (VOID_TYPE_P (TREE_TYPE (type2)))
2722         {
2723           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2724             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2725           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2726                                                           TREE_TYPE (type1)));
2727         }
2728       else
2729         {
2730           pedwarn ("pointer type mismatch in conditional expression");
2731           result_type = build_pointer_type (void_type_node);
2732         }
2733     }
2734   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2735     {
2736       if (! integer_zerop (op2))
2737         pedwarn ("pointer/integer type mismatch in conditional expression");
2738       else
2739         {
2740           op2 = null_pointer_node;
2741         }
2742       result_type = type1;
2743     }
2744   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2745     {
2746       if (!integer_zerop (op1))
2747         pedwarn ("pointer/integer type mismatch in conditional expression");
2748       else
2749         {
2750           op1 = null_pointer_node;
2751         }
2752       result_type = type2;
2753     }
2754
2755   if (!result_type)
2756     {
2757       if (flag_cond_mismatch)
2758         result_type = void_type_node;
2759       else
2760         {
2761           error ("type mismatch in conditional expression");
2762           return error_mark_node;
2763         }
2764     }
2765
2766   /* Merge const and volatile flags of the incoming types.  */
2767   result_type
2768     = build_type_variant (result_type,
2769                           TREE_READONLY (op1) || TREE_READONLY (op2),
2770                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
2771
2772   if (result_type != TREE_TYPE (op1))
2773     op1 = convert_and_check (result_type, op1);
2774   if (result_type != TREE_TYPE (op2))
2775     op2 = convert_and_check (result_type, op2);
2776
2777   if (TREE_CODE (ifexp) == INTEGER_CST)
2778     return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
2779
2780   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
2781 }
2782 \f
2783 /* Given a list of expressions, return a compound expression
2784    that performs them all and returns the value of the last of them.  */
2785
2786 tree
2787 build_compound_expr (tree list)
2788 {
2789   return internal_build_compound_expr (list, TRUE);
2790 }
2791
2792 static tree
2793 internal_build_compound_expr (tree list, int first_p)
2794 {
2795   tree rest;
2796
2797   if (TREE_CHAIN (list) == 0)
2798     {
2799       /* Convert arrays and functions to pointers when there
2800          really is a comma operator.  */
2801       if (!first_p)
2802         TREE_VALUE (list)
2803           = default_function_array_conversion (TREE_VALUE (list));
2804
2805       /* Don't let (0, 0) be null pointer constant.  */
2806       if (!first_p && integer_zerop (TREE_VALUE (list)))
2807         return non_lvalue (TREE_VALUE (list));
2808       return TREE_VALUE (list);
2809     }
2810
2811   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
2812
2813   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
2814     {
2815       /* The left-hand operand of a comma expression is like an expression
2816          statement: with -Wextra or -Wunused, we should warn if it doesn't have
2817          any side-effects, unless it was explicitly cast to (void).  */
2818       if (warn_unused_value
2819            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
2820                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
2821         warning ("left-hand operand of comma expression has no effect");
2822     }
2823
2824   /* With -Wunused, we should also warn if the left-hand operand does have
2825      side-effects, but computes a value which is not used.  For example, in
2826      `foo() + bar(), baz()' the result of the `+' operator is not used,
2827      so we should issue a warning.  */
2828   else if (warn_unused_value)
2829     warn_if_unused_value (TREE_VALUE (list));
2830
2831   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
2832 }
2833
2834 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
2835
2836 tree
2837 build_c_cast (tree type, tree expr)
2838 {
2839   tree value = expr;
2840
2841   if (type == error_mark_node || expr == error_mark_node)
2842     return error_mark_node;
2843
2844   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
2845      only in <protocol> qualifications.  But when constructing cast expressions,
2846      the protocols do matter and must be kept around.  */
2847   if (!c_dialect_objc () || !objc_is_object_ptr (type))
2848     type = TYPE_MAIN_VARIANT (type);
2849
2850   if (TREE_CODE (type) == ARRAY_TYPE)
2851     {
2852       error ("cast specifies array type");
2853       return error_mark_node;
2854     }
2855
2856   if (TREE_CODE (type) == FUNCTION_TYPE)
2857     {
2858       error ("cast specifies function type");
2859       return error_mark_node;
2860     }
2861
2862   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
2863     {
2864       if (pedantic)
2865         {
2866           if (TREE_CODE (type) == RECORD_TYPE
2867               || TREE_CODE (type) == UNION_TYPE)
2868             pedwarn ("ISO C forbids casting nonscalar to the same type");
2869         }
2870     }
2871   else if (TREE_CODE (type) == UNION_TYPE)
2872     {
2873       tree field;
2874       value = default_function_array_conversion (value);
2875
2876       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2877         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
2878                        TYPE_MAIN_VARIANT (TREE_TYPE (value)), COMPARE_STRICT))
2879           break;
2880
2881       if (field)
2882         {
2883           tree t;
2884
2885           if (pedantic)
2886             pedwarn ("ISO C forbids casts to union type");
2887           t = digest_init (type,
2888                            build_constructor (type,
2889                                               build_tree_list (field, value)),
2890                            0);
2891           TREE_CONSTANT (t) = TREE_CONSTANT (value);
2892           return t;
2893         }
2894       error ("cast to union type from type not present in union");
2895       return error_mark_node;
2896     }
2897   else
2898     {
2899       tree otype, ovalue;
2900
2901       /* If casting to void, avoid the error that would come
2902          from default_conversion in the case of a non-lvalue array.  */
2903       if (type == void_type_node)
2904         return build1 (CONVERT_EXPR, type, value);
2905
2906       /* Convert functions and arrays to pointers,
2907          but don't convert any other types.  */
2908       value = default_function_array_conversion (value);
2909       otype = TREE_TYPE (value);
2910
2911       /* Optionally warn about potentially worrisome casts.  */
2912
2913       if (warn_cast_qual
2914           && TREE_CODE (type) == POINTER_TYPE
2915           && TREE_CODE (otype) == POINTER_TYPE)
2916         {
2917           tree in_type = type;
2918           tree in_otype = otype;
2919           int added = 0;
2920           int discarded = 0;
2921
2922           /* Check that the qualifiers on IN_TYPE are a superset of
2923              the qualifiers of IN_OTYPE.  The outermost level of
2924              POINTER_TYPE nodes is uninteresting and we stop as soon
2925              as we hit a non-POINTER_TYPE node on either type.  */
2926           do
2927             {
2928               in_otype = TREE_TYPE (in_otype);
2929               in_type = TREE_TYPE (in_type);
2930
2931               /* GNU C allows cv-qualified function types.  'const'
2932                  means the function is very pure, 'volatile' means it
2933                  can't return.  We need to warn when such qualifiers
2934                  are added, not when they're taken away.  */
2935               if (TREE_CODE (in_otype) == FUNCTION_TYPE
2936                   && TREE_CODE (in_type) == FUNCTION_TYPE)
2937                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
2938               else
2939                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
2940             }
2941           while (TREE_CODE (in_type) == POINTER_TYPE
2942                  && TREE_CODE (in_otype) == POINTER_TYPE);
2943
2944           if (added)
2945             warning ("cast adds new qualifiers to function type");
2946
2947           if (discarded)
2948             /* There are qualifiers present in IN_OTYPE that are not
2949                present in IN_TYPE.  */
2950             warning ("cast discards qualifiers from pointer target type");
2951         }
2952
2953       /* Warn about possible alignment problems.  */
2954       if (STRICT_ALIGNMENT && warn_cast_align
2955           && TREE_CODE (type) == POINTER_TYPE
2956           && TREE_CODE (otype) == POINTER_TYPE
2957           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
2958           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
2959           /* Don't warn about opaque types, where the actual alignment
2960              restriction is unknown.  */
2961           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
2962                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
2963                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
2964           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
2965         warning ("cast increases required alignment of target type");
2966
2967       if (TREE_CODE (type) == INTEGER_TYPE
2968           && TREE_CODE (otype) == POINTER_TYPE
2969           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
2970           && !TREE_CONSTANT (value))
2971         warning ("cast from pointer to integer of different size");
2972
2973       if (warn_bad_function_cast
2974           && TREE_CODE (value) == CALL_EXPR
2975           && TREE_CODE (type) != TREE_CODE (otype))
2976         warning ("cast does not match function type");
2977
2978       if (TREE_CODE (type) == POINTER_TYPE
2979           && TREE_CODE (otype) == INTEGER_TYPE
2980           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
2981           /* Don't warn about converting any constant.  */
2982           && !TREE_CONSTANT (value))
2983         warning ("cast to pointer from integer of different size");
2984
2985       if (TREE_CODE (type) == POINTER_TYPE
2986           && TREE_CODE (otype) == POINTER_TYPE
2987           && TREE_CODE (expr) == ADDR_EXPR
2988           && DECL_P (TREE_OPERAND (expr, 0))
2989           && flag_strict_aliasing && warn_strict_aliasing
2990           && !VOID_TYPE_P (TREE_TYPE (type)))
2991         {
2992           /* Casting the address of a decl to non void pointer. Warn
2993              if the cast breaks type based aliasing.  */
2994           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
2995             warning ("type-punning to incomplete type might break strict-aliasing rules");
2996           else if (!alias_sets_conflict_p
2997                    (get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0))),
2998                     get_alias_set (TREE_TYPE (type))))
2999             warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3000         }
3001
3002       /* If pedantic, warn for conversions between function and object
3003          pointer types, except for converting a null pointer constant
3004          to function pointer type.  */
3005       if (pedantic
3006           && TREE_CODE (type) == POINTER_TYPE
3007           && TREE_CODE (otype) == POINTER_TYPE
3008           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3009           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3010         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3011
3012       if (pedantic
3013           && TREE_CODE (type) == POINTER_TYPE
3014           && TREE_CODE (otype) == POINTER_TYPE
3015           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3016           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3017           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3018                && TREE_CODE (expr) != NOP_EXPR))
3019         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3020
3021       ovalue = value;
3022       /* Replace a nonvolatile const static variable with its value.  */
3023       if (optimize && TREE_CODE (value) == VAR_DECL)
3024         value = decl_constant_value (value);
3025       value = convert (type, value);
3026
3027       /* Ignore any integer overflow caused by the cast.  */
3028       if (TREE_CODE (value) == INTEGER_CST)
3029         {
3030           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3031           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3032         }
3033     }
3034
3035   /* Don't let (void *) (FOO *) 0 be a null pointer constant.  */
3036   if (TREE_CODE (value) == INTEGER_CST
3037       && TREE_CODE (expr) == INTEGER_CST
3038       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3039     value = non_lvalue (value);
3040
3041   /* Don't let a cast be an lvalue.  */
3042   if (value == expr)
3043     value = non_lvalue (value);
3044
3045   return value;
3046 }
3047
3048 /* Interpret a cast of expression EXPR to type TYPE.  */
3049 tree
3050 c_cast_expr (tree type, tree expr)
3051 {
3052   int saved_wsp = warn_strict_prototypes;
3053
3054   /* This avoids warnings about unprototyped casts on
3055      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3056   if (TREE_CODE (expr) == INTEGER_CST)
3057     warn_strict_prototypes = 0;
3058   type = groktypename (type);
3059   warn_strict_prototypes = saved_wsp;
3060
3061   return build_c_cast (type, expr);
3062 }
3063
3064 \f
3065 /* Build an assignment expression of lvalue LHS from value RHS.
3066    MODIFYCODE is the code for a binary operator that we use
3067    to combine the old value of LHS with RHS to get the new value.
3068    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3069
3070 tree
3071 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3072 {
3073   tree result;
3074   tree newrhs;
3075   tree lhstype = TREE_TYPE (lhs);
3076   tree olhstype = lhstype;
3077
3078   /* Types that aren't fully specified cannot be used in assignments.  */
3079   lhs = require_complete_type (lhs);
3080
3081   /* Avoid duplicate error messages from operands that had errors.  */
3082   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3083     return error_mark_node;
3084
3085   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3086   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3087      whose value is 0 to count as a null pointer constant.  */
3088   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3089     rhs = TREE_OPERAND (rhs, 0);
3090
3091   newrhs = rhs;
3092
3093   /* If a binary op has been requested, combine the old LHS value with the RHS
3094      producing the value we should actually store into the LHS.  */
3095
3096   if (modifycode != NOP_EXPR)
3097     {
3098       lhs = stabilize_reference (lhs);
3099       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3100     }
3101
3102   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3103     return error_mark_node;
3104
3105   /* Warn about storing in something that is `const'.  */
3106
3107   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3108       || ((TREE_CODE (lhstype) == RECORD_TYPE
3109            || TREE_CODE (lhstype) == UNION_TYPE)
3110           && C_TYPE_FIELDS_READONLY (lhstype)))
3111     readonly_warning (lhs, "assignment");
3112
3113   /* If storing into a structure or union member,
3114      it has probably been given type `int'.
3115      Compute the type that would go with
3116      the actual amount of storage the member occupies.  */
3117
3118   if (TREE_CODE (lhs) == COMPONENT_REF
3119       && (TREE_CODE (lhstype) == INTEGER_TYPE
3120           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3121           || TREE_CODE (lhstype) == REAL_TYPE
3122           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3123     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3124
3125   /* If storing in a field that is in actuality a short or narrower than one,
3126      we must store in the field in its actual type.  */
3127
3128   if (lhstype != TREE_TYPE (lhs))
3129     {
3130       lhs = copy_node (lhs);
3131       TREE_TYPE (lhs) = lhstype;
3132     }
3133
3134   /* Convert new value to destination type.  */
3135
3136   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3137                                    NULL_TREE, NULL_TREE, 0);
3138   if (TREE_CODE (newrhs) == ERROR_MARK)
3139     return error_mark_node;
3140
3141   /* Scan operands */
3142
3143   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3144   TREE_SIDE_EFFECTS (result) = 1;
3145
3146   /* If we got the LHS in a different type for storing in,
3147      convert the result back to the nominal type of LHS
3148      so that the value we return always has the same type
3149      as the LHS argument.  */
3150
3151   if (olhstype == TREE_TYPE (result))
3152     return result;
3153   return convert_for_assignment (olhstype, result, _("assignment"),
3154                                  NULL_TREE, NULL_TREE, 0);
3155 }
3156 \f
3157 /* Convert value RHS to type TYPE as preparation for an assignment
3158    to an lvalue of type TYPE.
3159    The real work of conversion is done by `convert'.
3160    The purpose of this function is to generate error messages
3161    for assignments that are not allowed in C.
3162    ERRTYPE is a string to use in error messages:
3163    "assignment", "return", etc.  If it is null, this is parameter passing
3164    for a function call (and different error messages are output).
3165
3166    FUNNAME is the name of the function being called,
3167    as an IDENTIFIER_NODE, or null.
3168    PARMNUM is the number of the argument, for printing in error messages.  */
3169
3170 static tree
3171 convert_for_assignment (tree type, tree rhs, const char *errtype,
3172                         tree fundecl, tree funname, int parmnum)
3173 {
3174   enum tree_code codel = TREE_CODE (type);
3175   tree rhstype;
3176   enum tree_code coder;
3177
3178   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3179   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3180      whose value is 0 to count as a null pointer constant.  */
3181   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3182     rhs = TREE_OPERAND (rhs, 0);
3183
3184   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3185       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3186     rhs = default_conversion (rhs);
3187   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3188     rhs = decl_constant_value_for_broken_optimization (rhs);
3189
3190   rhstype = TREE_TYPE (rhs);
3191   coder = TREE_CODE (rhstype);
3192
3193   if (coder == ERROR_MARK)
3194     return error_mark_node;
3195
3196   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3197     {
3198       overflow_warning (rhs);
3199       /* Check for Objective-C protocols.  This will automatically
3200          issue a warning if there are protocol violations.  No need to
3201          use the return value.  */
3202       if (c_dialect_objc ())
3203         objc_comptypes (type, rhstype, 0);
3204       return rhs;
3205     }
3206
3207   if (coder == VOID_TYPE)
3208     {
3209       error ("void value not ignored as it ought to be");
3210       return error_mark_node;
3211     }
3212   /* A type converts to a reference to it.
3213      This code doesn't fully support references, it's just for the
3214      special case of va_start and va_copy.  */
3215   if (codel == REFERENCE_TYPE
3216       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs), COMPARE_STRICT) == 1)
3217     {
3218       if (!lvalue_p (rhs))
3219         {
3220           error ("cannot pass rvalue to reference parameter");
3221           return error_mark_node;
3222         }
3223       if (!c_mark_addressable (rhs))
3224         return error_mark_node;
3225       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3226
3227       /* We already know that these two types are compatible, but they
3228          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3229          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3230          likely to be va_list, a typedef to __builtin_va_list, which
3231          is different enough that it will cause problems later.  */
3232       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3233         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3234
3235       rhs = build1 (NOP_EXPR, type, rhs);
3236       return rhs;
3237     }
3238   /* Some types can interconvert without explicit casts.  */
3239   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3240            && ((*targetm.vector_opaque_p) (type)
3241                || (*targetm.vector_opaque_p) (rhstype)))
3242     return convert (type, rhs);
3243   /* Arithmetic types all interconvert, and enum is treated like int.  */
3244   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3245             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3246             || codel == BOOLEAN_TYPE)
3247            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3248                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3249                || coder == BOOLEAN_TYPE))
3250     return convert_and_check (type, rhs);
3251
3252   /* Conversion to a transparent union from its member types.
3253      This applies only to function arguments.  */
3254   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
3255     {
3256       tree memb_types;
3257       tree marginal_memb_type = 0;
3258
3259       for (memb_types = TYPE_FIELDS (type); memb_types;
3260            memb_types = TREE_CHAIN (memb_types))
3261         {
3262           tree memb_type = TREE_TYPE (memb_types);
3263
3264           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3265                          TYPE_MAIN_VARIANT (rhstype), COMPARE_STRICT))
3266             break;
3267
3268           if (TREE_CODE (memb_type) != POINTER_TYPE)
3269             continue;
3270
3271           if (coder == POINTER_TYPE)
3272             {
3273               tree ttl = TREE_TYPE (memb_type);
3274               tree ttr = TREE_TYPE (rhstype);
3275
3276               /* Any non-function converts to a [const][volatile] void *
3277                  and vice versa; otherwise, targets must be the same.
3278                  Meanwhile, the lhs target must have all the qualifiers of
3279                  the rhs.  */
3280               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3281                   || comp_target_types (memb_type, rhstype, 0))
3282                 {
3283                   /* If this type won't generate any warnings, use it.  */
3284                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3285                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3286                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3287                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3288                              == TYPE_QUALS (ttr))
3289                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3290                              == TYPE_QUALS (ttl))))
3291                     break;
3292
3293                   /* Keep looking for a better type, but remember this one.  */
3294                   if (! marginal_memb_type)
3295                     marginal_memb_type = memb_type;
3296                 }
3297             }
3298
3299           /* Can convert integer zero to any pointer type.  */
3300           if (integer_zerop (rhs)
3301               || (TREE_CODE (rhs) == NOP_EXPR
3302                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3303             {
3304               rhs = null_pointer_node;
3305               break;
3306             }
3307         }
3308
3309       if (memb_types || marginal_memb_type)
3310         {
3311           if (! memb_types)
3312             {
3313               /* We have only a marginally acceptable member type;
3314                  it needs a warning.  */
3315               tree ttl = TREE_TYPE (marginal_memb_type);
3316               tree ttr = TREE_TYPE (rhstype);
3317
3318               /* Const and volatile mean something different for function
3319                  types, so the usual warnings are not appropriate.  */
3320               if (TREE_CODE (ttr) == FUNCTION_TYPE
3321                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3322                 {
3323                   /* Because const and volatile on functions are
3324                      restrictions that say the function will not do
3325                      certain things, it is okay to use a const or volatile
3326                      function where an ordinary one is wanted, but not
3327                      vice-versa.  */
3328                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3329                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
3330                                          errtype, funname, parmnum);
3331                 }
3332               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3333                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3334                                      errtype, funname,
3335                                      parmnum);
3336             }
3337
3338           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
3339             pedwarn ("ISO C prohibits argument conversion to union type");
3340
3341           return build1 (NOP_EXPR, type, rhs);
3342         }
3343     }
3344
3345   /* Conversions among pointers */
3346   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3347            && (coder == codel))
3348     {
3349       tree ttl = TREE_TYPE (type);
3350       tree ttr = TREE_TYPE (rhstype);
3351       bool is_opaque_pointer;
3352       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3353
3354       /* Opaque pointers are treated like void pointers.  */
3355       is_opaque_pointer = ((*targetm.vector_opaque_p) (type)
3356                            || (*targetm.vector_opaque_p) (rhstype))
3357         && TREE_CODE (ttl) == VECTOR_TYPE
3358         && TREE_CODE (ttr) == VECTOR_TYPE;
3359
3360       /* Any non-function converts to a [const][volatile] void *
3361          and vice versa; otherwise, targets must be the same.
3362          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3363       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3364           || (target_cmp = comp_target_types (type, rhstype, 0))
3365           || is_opaque_pointer
3366           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3367               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3368         {
3369           if (pedantic
3370               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3371                   ||
3372                   (VOID_TYPE_P (ttr)
3373                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3374                       which are not ANSI null ptr constants.  */
3375                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3376                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3377             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
3378                                  errtype, funname, parmnum);
3379           /* Const and volatile mean something different for function types,
3380              so the usual warnings are not appropriate.  */
3381           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3382                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3383             {
3384               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3385                 warn_for_assignment ("%s discards qualifiers from pointer target type",
3386                                      errtype, funname, parmnum);
3387               /* If this is not a case of ignoring a mismatch in signedness,
3388                  no warning.  */
3389               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3390                        || target_cmp)
3391                 ;
3392               /* If there is a mismatch, do warn.  */
3393               else if (pedantic)
3394                 warn_for_assignment ("pointer targets in %s differ in signedness",
3395                                      errtype, funname, parmnum);
3396             }
3397           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3398                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3399             {
3400               /* Because const and volatile on functions are restrictions
3401                  that say the function will not do certain things,
3402                  it is okay to use a const or volatile function
3403                  where an ordinary one is wanted, but not vice-versa.  */
3404               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3405                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3406                                      errtype, funname, parmnum);
3407             }
3408         }
3409       else
3410         warn_for_assignment ("%s from incompatible pointer type",
3411                              errtype, funname, parmnum);
3412       return convert (type, rhs);
3413     }
3414   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3415     {
3416       error ("invalid use of non-lvalue array");
3417       return error_mark_node;
3418     }
3419   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3420     {
3421       /* An explicit constant 0 can convert to a pointer,
3422          or one that results from arithmetic, even including
3423          a cast to integer type.  */
3424       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3425           &&
3426           ! (TREE_CODE (rhs) == NOP_EXPR
3427              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3428              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3429              && integer_zerop (TREE_OPERAND (rhs, 0))))
3430           warn_for_assignment ("%s makes pointer from integer without a cast",
3431                                errtype, funname, parmnum);
3432
3433       return convert (type, rhs);
3434     }
3435   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3436     {
3437       warn_for_assignment ("%s makes integer from pointer without a cast",
3438                            errtype, funname, parmnum);
3439       return convert (type, rhs);
3440     }
3441   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3442     return convert (type, rhs);
3443
3444   if (!errtype)
3445     {
3446       if (funname)
3447         {
3448           tree selector = objc_message_selector ();
3449
3450           if (selector && parmnum > 2)
3451             error ("incompatible type for argument %d of `%s'",
3452                    parmnum - 2, IDENTIFIER_POINTER (selector));
3453           else
3454             error ("incompatible type for argument %d of `%s'",
3455                    parmnum, IDENTIFIER_POINTER (funname));
3456         }
3457       else
3458         error ("incompatible type for argument %d of indirect function call",
3459                parmnum);
3460     }
3461   else
3462     error ("incompatible types in %s", errtype);
3463
3464   return error_mark_node;
3465 }
3466
3467 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3468    is used for error and waring reporting and indicates which argument
3469    is being processed.  */
3470
3471 tree
3472 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3473 {
3474   tree ret, type;
3475
3476   /* If FN was prototyped, the value has been converted already
3477      in convert_arguments.  */
3478   if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3479     return value;
3480
3481   type = TREE_TYPE (parm);
3482   ret = convert_for_assignment (type, value,
3483                                 (char *) 0 /* arg passing  */, fn,
3484                                 DECL_NAME (fn), argnum);
3485   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3486       && INTEGRAL_TYPE_P (type)
3487       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3488     ret = default_conversion (ret);
3489   return ret;
3490 }
3491
3492 /* Print a warning using MSGID.
3493    It gets OPNAME as its one parameter.
3494    if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
3495    Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
3496    FUNCTION and ARGNUM are handled specially if we are building an
3497    Objective-C selector.  */
3498
3499 static void
3500 warn_for_assignment (const char *msgid, const char *opname, tree function,
3501                      int argnum)
3502 {
3503   if (opname == 0)
3504     {
3505       tree selector = objc_message_selector ();
3506       char * new_opname;
3507
3508       if (selector && argnum > 2)
3509         {
3510           function = selector;
3511           argnum -= 2;
3512         }
3513       if (argnum == 0)
3514         {
3515           if (function)
3516             {
3517               /* Function name is known; supply it.  */
3518               const char *const argstring = _("passing arg of `%s'");
3519               new_opname = alloca (IDENTIFIER_LENGTH (function)
3520                                    + strlen (argstring) + 1 + 1);
3521               sprintf (new_opname, argstring,
3522                        IDENTIFIER_POINTER (function));
3523             }
3524           else
3525             {
3526               /* Function name unknown (call through ptr).  */
3527               const char *const argnofun = _("passing arg of pointer to function");
3528               new_opname = alloca (strlen (argnofun) + 1 + 1);
3529               sprintf (new_opname, argnofun);
3530             }
3531         }
3532       else if (function)
3533         {
3534           /* Function name is known; supply it.  */
3535           const char *const argstring = _("passing arg %d of `%s'");
3536           new_opname = alloca (IDENTIFIER_LENGTH (function)
3537                                + strlen (argstring) + 1 + 25 /*%d*/ + 1);
3538           sprintf (new_opname, argstring, argnum,
3539                    IDENTIFIER_POINTER (function));
3540         }
3541       else
3542         {
3543           /* Function name unknown (call through ptr); just give arg number.  */
3544           const char *const argnofun = _("passing arg %d of pointer to function");
3545           new_opname = alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
3546           sprintf (new_opname, argnofun, argnum);
3547         }
3548       opname = new_opname;
3549     }
3550   pedwarn (msgid, opname);
3551 }
3552 \f
3553 /* If VALUE is a compound expr all of whose expressions are constant, then
3554    return its value.  Otherwise, return error_mark_node.
3555
3556    This is for handling COMPOUND_EXPRs as initializer elements
3557    which is allowed with a warning when -pedantic is specified.  */
3558
3559 static tree
3560 valid_compound_expr_initializer (tree value, tree endtype)
3561 {
3562   if (TREE_CODE (value) == COMPOUND_EXPR)
3563     {
3564       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3565           == error_mark_node)
3566         return error_mark_node;
3567       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3568                                               endtype);
3569     }
3570   else if (! TREE_CONSTANT (value)
3571            && ! initializer_constant_valid_p (value, endtype))
3572     return error_mark_node;
3573   else
3574     return value;
3575 }
3576 \f
3577 /* Perform appropriate conversions on the initial value of a variable,
3578    store it in the declaration DECL,
3579    and print any error messages that are appropriate.
3580    If the init is invalid, store an ERROR_MARK.  */
3581
3582 void
3583 store_init_value (tree decl, tree init)
3584 {
3585   tree value, type;
3586
3587   /* If variable's type was invalidly declared, just ignore it.  */
3588
3589   type = TREE_TYPE (decl);
3590   if (TREE_CODE (type) == ERROR_MARK)
3591     return;
3592
3593   /* Digest the specified initializer into an expression.  */
3594
3595   value = digest_init (type, init, TREE_STATIC (decl));
3596
3597   /* Store the expression if valid; else report error.  */
3598
3599   if (warn_traditional && !in_system_header
3600       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
3601     warning ("traditional C rejects automatic aggregate initialization");
3602
3603   DECL_INITIAL (decl) = value;
3604
3605   /* ANSI wants warnings about out-of-range constant initializers.  */
3606   STRIP_TYPE_NOPS (value);
3607   constant_expression_warning (value);
3608
3609   /* Check if we need to set array size from compound literal size.  */
3610   if (TREE_CODE (type) == ARRAY_TYPE
3611       && TYPE_DOMAIN (type) == 0
3612       && value != error_mark_node)
3613     {
3614       tree inside_init = init;
3615
3616       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3617         inside_init = TREE_OPERAND (init, 0);
3618       inside_init = fold (inside_init);
3619
3620       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3621         {
3622           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3623
3624           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3625             {
3626               /* For int foo[] = (int [3]){1}; we need to set array size
3627                  now since later on array initializer will be just the
3628                  brace enclosed list of the compound literal.  */
3629               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3630               layout_type (type);
3631               layout_decl (decl, 0);
3632             }
3633         }
3634     }
3635 }
3636 \f
3637 /* Methods for storing and printing names for error messages.  */
3638
3639 /* Implement a spelling stack that allows components of a name to be pushed
3640    and popped.  Each element on the stack is this structure.  */
3641
3642 struct spelling
3643 {
3644   int kind;
3645   union
3646     {
3647       int i;
3648       const char *s;
3649     } u;
3650 };
3651
3652 #define SPELLING_STRING 1
3653 #define SPELLING_MEMBER 2
3654 #define SPELLING_BOUNDS 3
3655
3656 static struct spelling *spelling;       /* Next stack element (unused).  */
3657 static struct spelling *spelling_base;  /* Spelling stack base.  */
3658 static int spelling_size;               /* Size of the spelling stack.  */
3659
3660 /* Macros to save and restore the spelling stack around push_... functions.
3661    Alternative to SAVE_SPELLING_STACK.  */
3662
3663 #define SPELLING_DEPTH() (spelling - spelling_base)
3664 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3665
3666 /* Push an element on the spelling stack with type KIND and assign VALUE
3667    to MEMBER.  */
3668
3669 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3670 {                                                                       \
3671   int depth = SPELLING_DEPTH ();                                        \
3672                                                                         \
3673   if (depth >= spelling_size)                                           \
3674     {                                                                   \
3675       spelling_size += 10;                                              \
3676       if (spelling_base == 0)                                           \
3677         spelling_base = xmalloc (spelling_size * sizeof (struct spelling)); \
3678       else                                                              \
3679         spelling_base = xrealloc (spelling_base,                \
3680                                   spelling_size * sizeof (struct spelling)); \
3681       RESTORE_SPELLING_DEPTH (depth);                                   \
3682     }                                                                   \
3683                                                                         \
3684   spelling->kind = (KIND);                                              \
3685   spelling->MEMBER = (VALUE);                                           \
3686   spelling++;                                                           \
3687 }
3688
3689 /* Push STRING on the stack.  Printed literally.  */
3690
3691 static void
3692 push_string (const char *string)
3693 {
3694   PUSH_SPELLING (SPELLING_STRING, string, u.s);
3695 }
3696
3697 /* Push a member name on the stack.  Printed as '.' STRING.  */
3698
3699 static void
3700 push_member_name (tree decl)
3701 {
3702   const char *const string
3703     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3704   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3705 }
3706
3707 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
3708
3709 static void
3710 push_array_bounds (int bounds)
3711 {
3712   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3713 }
3714
3715 /* Compute the maximum size in bytes of the printed spelling.  */
3716
3717 static int
3718 spelling_length (void)
3719 {
3720   int size = 0;
3721   struct spelling *p;
3722
3723   for (p = spelling_base; p < spelling; p++)
3724     {
3725       if (p->kind == SPELLING_BOUNDS)
3726         size += 25;
3727       else
3728         size += strlen (p->u.s) + 1;
3729     }
3730
3731   return size;
3732 }
3733
3734 /* Print the spelling to BUFFER and return it.  */
3735
3736 static char *
3737 print_spelling (char *buffer)
3738 {
3739   char *d = buffer;
3740   struct spelling *p;
3741
3742   for (p = spelling_base; p < spelling; p++)
3743     if (p->kind == SPELLING_BOUNDS)
3744       {
3745         sprintf (d, "[%d]", p->u.i);
3746         d += strlen (d);
3747       }
3748     else
3749       {
3750         const char *s;
3751         if (p->kind == SPELLING_MEMBER)
3752           *d++ = '.';
3753         for (s = p->u.s; (*d = *s++); d++)
3754           ;
3755       }
3756   *d++ = '\0';
3757   return buffer;
3758 }
3759
3760 /* Issue an error message for a bad initializer component.
3761    MSGID identifies the message.
3762    The component name is taken from the spelling stack.  */
3763
3764 void
3765 error_init (const char *msgid)
3766 {
3767   char *ofwhat;
3768
3769   error ("%s", _(msgid));
3770   ofwhat = print_spelling (alloca (spelling_length () + 1));
3771   if (*ofwhat)
3772     error ("(near initialization for `%s')", ofwhat);
3773 }
3774
3775 /* Issue a pedantic warning for a bad initializer component.
3776    MSGID identifies the message.
3777    The component name is taken from the spelling stack.  */
3778
3779 void
3780 pedwarn_init (const char *msgid)
3781 {
3782   char *ofwhat;
3783
3784   pedwarn ("%s", _(msgid));
3785   ofwhat = print_spelling (alloca (spelling_length () + 1));
3786   if (*ofwhat)
3787     pedwarn ("(near initialization for `%s')", ofwhat);
3788 }
3789
3790 /* Issue a warning for a bad initializer component.
3791    MSGID identifies the message.
3792    The component name is taken from the spelling stack.  */
3793
3794 static void
3795 warning_init (const char *msgid)
3796 {
3797   char *ofwhat;
3798
3799   warning ("%s", _(msgid));
3800   ofwhat = print_spelling (alloca (spelling_length () + 1));
3801   if (*ofwhat)
3802     warning ("(near initialization for `%s')", ofwhat);
3803 }
3804 \f
3805 /* Digest the parser output INIT as an initializer for type TYPE.
3806    Return a C expression of type TYPE to represent the initial value.
3807
3808    REQUIRE_CONSTANT requests an error if non-constant initializers or
3809    elements are seen.  */
3810
3811 static tree
3812 digest_init (tree type, tree init, int require_constant)
3813 {
3814   enum tree_code code = TREE_CODE (type);
3815   tree inside_init = init;
3816
3817   if (type == error_mark_node
3818       || init == error_mark_node
3819       || TREE_TYPE (init) == error_mark_node)
3820     return error_mark_node;
3821
3822   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3823   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3824      whose value is 0 to count as a null pointer constant.  */
3825   if (TREE_CODE (init) == NON_LVALUE_EXPR)
3826     inside_init = TREE_OPERAND (init, 0);
3827
3828   inside_init = fold (inside_init);
3829
3830   /* Initialization of an array of chars from a string constant
3831      optionally enclosed in braces.  */
3832
3833   if (code == ARRAY_TYPE)
3834     {
3835       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3836       if ((typ1 == char_type_node
3837            || typ1 == signed_char_type_node
3838            || typ1 == unsigned_char_type_node
3839            || typ1 == unsigned_wchar_type_node
3840            || typ1 == signed_wchar_type_node)
3841           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
3842         {
3843           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3844                          TYPE_MAIN_VARIANT (type), COMPARE_STRICT))
3845             return inside_init;
3846
3847           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
3848                != char_type_node)
3849               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
3850             {
3851               error_init ("char-array initialized from wide string");
3852               return error_mark_node;
3853             }
3854           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
3855                == char_type_node)
3856               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
3857             {
3858               error_init ("int-array initialized from non-wide string");
3859               return error_mark_node;
3860             }
3861
3862           TREE_TYPE (inside_init) = type;
3863           if (TYPE_DOMAIN (type) != 0
3864               && TYPE_SIZE (type) != 0
3865               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
3866               /* Subtract 1 (or sizeof (wchar_t))
3867                  because it's ok to ignore the terminating null char
3868                  that is counted in the length of the constant.  */
3869               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
3870                                        TREE_STRING_LENGTH (inside_init)
3871                                        - ((TYPE_PRECISION (typ1)
3872                                            != TYPE_PRECISION (char_type_node))
3873                                           ? (TYPE_PRECISION (wchar_type_node)
3874                                              / BITS_PER_UNIT)
3875                                           : 1)))
3876             pedwarn_init ("initializer-string for array of chars is too long");
3877
3878           return inside_init;
3879         }
3880     }
3881
3882   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
3883      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
3884      below and handle as a constructor.  */
3885     if (code == VECTOR_TYPE
3886         && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT)
3887         && TREE_CONSTANT (inside_init))
3888       {
3889         if (TREE_CODE (inside_init) == VECTOR_CST
3890             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3891                           TYPE_MAIN_VARIANT (type),
3892                           COMPARE_STRICT))
3893           return inside_init;
3894         else
3895           return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
3896       }
3897
3898   /* Any type can be initialized
3899      from an expression of the same type, optionally with braces.  */
3900
3901   if (inside_init && TREE_TYPE (inside_init) != 0
3902       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
3903                      TYPE_MAIN_VARIANT (type), COMPARE_STRICT)
3904           || (code == ARRAY_TYPE
3905               && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
3906           || (code == VECTOR_TYPE
3907               && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
3908           || (code == POINTER_TYPE
3909               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
3910               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
3911                             TREE_TYPE (type), COMPARE_STRICT))
3912           || (code == POINTER_TYPE
3913               && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
3914               && comptypes (TREE_TYPE (inside_init),
3915                             TREE_TYPE (type), COMPARE_STRICT))))
3916     {
3917       if (code == POINTER_TYPE)
3918         {
3919           inside_init = default_function_array_conversion (inside_init);
3920
3921           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
3922             {
3923               error_init ("invalid use of non-lvalue array");
3924               return error_mark_node;
3925             }
3926          }
3927
3928       if (code == VECTOR_TYPE)
3929         /* Although the types are compatible, we may require a
3930            conversion.  */
3931         inside_init = convert (type, inside_init);
3932
3933       if (require_constant && !flag_isoc99
3934           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3935         {
3936           /* As an extension, allow initializing objects with static storage
3937              duration with compound literals (which are then treated just as
3938              the brace enclosed list they contain).  */
3939           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3940           inside_init = DECL_INITIAL (decl);
3941         }
3942
3943       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
3944           && TREE_CODE (inside_init) != CONSTRUCTOR)
3945         {
3946           error_init ("array initialized from non-constant array expression");
3947           return error_mark_node;
3948         }
3949
3950       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
3951         inside_init = decl_constant_value_for_broken_optimization (inside_init);
3952
3953       /* Compound expressions can only occur here if -pedantic or
3954          -pedantic-errors is specified.  In the later case, we always want
3955          an error.  In the former case, we simply want a warning.  */
3956       if (require_constant && pedantic
3957           && TREE_CODE (inside_init) == COMPOUND_EXPR)
3958         {
3959           inside_init
3960             = valid_compound_expr_initializer (inside_init,
3961                                                TREE_TYPE (inside_init));
3962           if (inside_init == error_mark_node)
3963             error_init ("initializer element is not constant");
3964           else
3965             pedwarn_init ("initializer element is not constant");
3966           if (flag_pedantic_errors)
3967             inside_init = error_mark_node;
3968         }
3969       else if (require_constant
3970                && (!TREE_CONSTANT (inside_init)
3971                    /* This test catches things like `7 / 0' which
3972                       result in an expression for which TREE_CONSTANT
3973                       is true, but which is not actually something
3974                       that is a legal constant.  We really should not
3975                       be using this function, because it is a part of
3976                       the back-end.  Instead, the expression should
3977                       already have been turned into ERROR_MARK_NODE.  */
3978                    || !initializer_constant_valid_p (inside_init,
3979                                                      TREE_TYPE (inside_init))))
3980         {
3981           error_init ("initializer element is not constant");
3982           inside_init = error_mark_node;
3983         }
3984
3985       return inside_init;
3986     }
3987
3988   /* Handle scalar types, including conversions.  */
3989
3990   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
3991       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
3992     {
3993       /* Note that convert_for_assignment calls default_conversion
3994          for arrays and functions.  We must not call it in the
3995          case where inside_init is a null pointer constant.  */
3996       inside_init
3997         = convert_for_assignment (type, init, _("initialization"),
3998                                   NULL_TREE, NULL_TREE, 0);
3999
4000       if (require_constant && ! TREE_CONSTANT (inside_init))
4001         {
4002           error_init ("initializer element is not constant");
4003           inside_init = error_mark_node;
4004         }
4005       else if (require_constant
4006                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4007         {
4008           error_init ("initializer element is not computable at load time");
4009           inside_init = error_mark_node;
4010         }
4011
4012       return inside_init;
4013     }
4014
4015   /* Come here only for records and arrays.  */
4016
4017   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4018     {
4019       error_init ("variable-sized object may not be initialized");
4020       return error_mark_node;
4021     }
4022
4023   error_init ("invalid initializer");
4024   return error_mark_node;
4025 }
4026 \f
4027 /* Handle initializers that use braces.  */
4028
4029 /* Type of object we are accumulating a constructor for.
4030    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4031 static tree constructor_type;
4032
4033 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4034    left to fill.  */
4035 static tree constructor_fields;
4036
4037 /* For an ARRAY_TYPE, this is the specified index
4038    at which to store the next element we get.  */
4039 static tree constructor_index;
4040
4041 /* For an ARRAY_TYPE, this is the maximum index.  */
4042 static tree constructor_max_index;
4043
4044 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4045 static tree constructor_unfilled_fields;
4046
4047 /* For an ARRAY_TYPE, this is the index of the first element
4048    not yet written out.  */
4049 static tree constructor_unfilled_index;
4050
4051 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4052    This is so we can generate gaps between fields, when appropriate.  */
4053 static tree constructor_bit_index;
4054
4055 /* If we are saving up the elements rather than allocating them,
4056    this is the list of elements so far (in reverse order,
4057    most recent first).  */
4058 static tree constructor_elements;
4059
4060 /* 1 if constructor should be incrementally stored into a constructor chain,
4061    0 if all the elements should be kept in AVL tree.  */
4062 static int constructor_incremental;
4063
4064 /* 1 if so far this constructor's elements are all compile-time constants.  */
4065 static int constructor_constant;
4066
4067 /* 1 if so far this constructor's elements are all valid address constants.  */
4068 static int constructor_simple;
4069
4070 /* 1 if this constructor is erroneous so far.  */
4071 static int constructor_erroneous;
4072
4073 /* Structure for managing pending initializer elements, organized as an
4074    AVL tree.  */
4075
4076 struct init_node
4077 {
4078   struct init_node *left, *right;
4079   struct init_node *parent;
4080   int balance;
4081   tree purpose;
4082   tree value;
4083 };
4084
4085 /* Tree of pending elements at this constructor level.
4086    These are elements encountered out of order
4087    which belong at places we haven't reached yet in actually
4088    writing the output.
4089    Will never hold tree nodes across GC runs.  */
4090 static struct init_node *constructor_pending_elts;
4091
4092 /* The SPELLING_DEPTH of this constructor.  */
4093 static int constructor_depth;
4094
4095 /* 0 if implicitly pushing constructor levels is allowed.  */
4096 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4097
4098 static int require_constant_value;
4099 static int require_constant_elements;
4100
4101 /* DECL node for which an initializer is being read.
4102    0 means we are reading a constructor expression
4103    such as (struct foo) {...}.  */
4104 static tree constructor_decl;
4105
4106 /* Nonzero if this is an initializer for a top-level decl.  */
4107 static int constructor_top_level;
4108
4109 /* Nonzero if there were any member designators in this initializer.  */
4110 static int constructor_designated;
4111
4112 /* Nesting depth of designator list.  */
4113 static int designator_depth;
4114
4115 /* Nonzero if there were diagnosed errors in this designator list.  */
4116 static int designator_errorneous;
4117
4118 \f
4119 /* This stack has a level for each implicit or explicit level of
4120    structuring in the initializer, including the outermost one.  It
4121    saves the values of most of the variables above.  */
4122
4123 struct constructor_range_stack;
4124
4125 struct constructor_stack
4126 {
4127   struct constructor_stack *next;
4128   tree type;
4129   tree fields;
4130   tree index;
4131   tree max_index;
4132   tree unfilled_index;
4133   tree unfilled_fields;
4134   tree bit_index;
4135   tree elements;
4136   struct init_node *pending_elts;
4137   int offset;
4138   int depth;
4139   /* If nonzero, this value should replace the entire
4140      constructor at this level.  */
4141   tree replacement_value;
4142   struct constructor_range_stack *range_stack;
4143   char constant;
4144   char simple;
4145   char implicit;
4146   char erroneous;
4147   char outer;
4148   char incremental;
4149   char designated;
4150 };
4151
4152 struct constructor_stack *constructor_stack;
4153
4154 /* This stack represents designators from some range designator up to
4155    the last designator in the list.  */
4156
4157 struct constructor_range_stack
4158 {
4159   struct constructor_range_stack *next, *prev;
4160   struct constructor_stack *stack;
4161   tree range_start;
4162   tree index;
4163   tree range_end;
4164   tree fields;
4165 };
4166
4167 struct constructor_range_stack *constructor_range_stack;
4168
4169 /* This stack records separate initializers that are nested.
4170    Nested initializers can't happen in ANSI C, but GNU C allows them
4171    in cases like { ... (struct foo) { ... } ... }.  */
4172
4173 struct initializer_stack
4174 {
4175   struct initializer_stack *next;
4176   tree decl;
4177   struct constructor_stack *constructor_stack;
4178   struct constructor_range_stack *constructor_range_stack;
4179   tree elements;
4180   struct spelling *spelling;
4181   struct spelling *spelling_base;
4182   int spelling_size;
4183   char top_level;
4184   char require_constant_value;
4185   char require_constant_elements;
4186 };
4187
4188 struct initializer_stack *initializer_stack;
4189 \f
4190 /* Prepare to parse and output the initializer for variable DECL.  */
4191
4192 void
4193 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
4194 {
4195   const char *locus;
4196   struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4197
4198   p->decl = constructor_decl;
4199   p->require_constant_value = require_constant_value;
4200   p->require_constant_elements = require_constant_elements;
4201   p->constructor_stack = constructor_stack;
4202   p->constructor_range_stack = constructor_range_stack;
4203   p->elements = constructor_elements;
4204   p->spelling = spelling;
4205   p->spelling_base = spelling_base;
4206   p->spelling_size = spelling_size;
4207   p->top_level = constructor_top_level;
4208   p->next = initializer_stack;
4209   initializer_stack = p;
4210
4211   constructor_decl = decl;
4212   constructor_designated = 0;
4213   constructor_top_level = top_level;
4214
4215   if (decl != 0)
4216     {
4217       require_constant_value = TREE_STATIC (decl);
4218       require_constant_elements
4219         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4220            /* For a scalar, you can always use any value to initialize,
4221               even within braces.  */
4222            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4223                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4224                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4225                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4226       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4227     }
4228   else
4229     {
4230       require_constant_value = 0;
4231       require_constant_elements = 0;
4232       locus = "(anonymous)";
4233     }
4234
4235   constructor_stack = 0;
4236   constructor_range_stack = 0;
4237
4238   missing_braces_mentioned = 0;
4239
4240   spelling_base = 0;
4241   spelling_size = 0;
4242   RESTORE_SPELLING_DEPTH (0);
4243
4244   if (locus)
4245     push_string (locus);
4246 }
4247
4248 void
4249 finish_init (void)
4250 {
4251   struct initializer_stack *p = initializer_stack;
4252
4253   /* Free the whole constructor stack of this initializer.  */
4254   while (constructor_stack)
4255     {
4256       struct constructor_stack *q = constructor_stack;
4257       constructor_stack = q->next;
4258       free (q);
4259     }
4260
4261   if (constructor_range_stack)
4262     abort ();
4263
4264   /* Pop back to the data of the outer initializer (if any).  */
4265   free (spelling_base);
4266
4267   constructor_decl = p->decl;
4268   require_constant_value = p->require_constant_value;
4269   require_constant_elements = p->require_constant_elements;
4270   constructor_stack = p->constructor_stack;
4271   constructor_range_stack = p->constructor_range_stack;
4272   constructor_elements = p->elements;
4273   spelling = p->spelling;
4274   spelling_base = p->spelling_base;
4275   spelling_size = p->spelling_size;
4276   constructor_top_level = p->top_level;
4277   initializer_stack = p->next;
4278   free (p);
4279 }
4280 \f
4281 /* Call here when we see the initializer is surrounded by braces.
4282    This is instead of a call to push_init_level;
4283    it is matched by a call to pop_init_level.
4284
4285    TYPE is the type to initialize, for a constructor expression.
4286    For an initializer for a decl, TYPE is zero.  */
4287
4288 void
4289 really_start_incremental_init (tree type)
4290 {
4291   struct constructor_stack *p = xmalloc (sizeof (struct constructor_stack));
4292
4293   if (type == 0)
4294     type = TREE_TYPE (constructor_decl);
4295
4296   if ((*targetm.vector_opaque_p) (type))
4297     error ("opaque vector types cannot be initialized");
4298
4299   p->type = constructor_type;
4300   p->fields = constructor_fields;
4301   p->index = constructor_index;
4302   p->max_index = constructor_max_index;
4303   p->unfilled_index = constructor_unfilled_index;
4304   p->unfilled_fields = constructor_unfilled_fields;
4305   p->bit_index = constructor_bit_index;
4306   p->elements = constructor_elements;
4307   p->constant = constructor_constant;
4308   p->simple = constructor_simple;
4309   p->erroneous = constructor_erroneous;
4310   p->pending_elts = constructor_pending_elts;
4311   p->depth = constructor_depth;
4312   p->replacement_value = 0;
4313   p->implicit = 0;
4314   p->range_stack = 0;
4315   p->outer = 0;
4316   p->incremental = constructor_incremental;
4317   p->designated = constructor_designated;
4318   p->next = 0;
4319   constructor_stack = p;
4320
4321   constructor_constant = 1;
4322   constructor_simple = 1;
4323   constructor_depth = SPELLING_DEPTH ();
4324   constructor_elements = 0;
4325   constructor_pending_elts = 0;
4326   constructor_type = type;
4327   constructor_incremental = 1;
4328   constructor_designated = 0;
4329   designator_depth = 0;
4330   designator_errorneous = 0;
4331
4332   if (TREE_CODE (constructor_type) == RECORD_TYPE
4333       || TREE_CODE (constructor_type) == UNION_TYPE)
4334     {
4335       constructor_fields = TYPE_FIELDS (constructor_type);
4336       /* Skip any nameless bit fields at the beginning.  */
4337       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4338              && DECL_NAME (constructor_fields) == 0)
4339         constructor_fields = TREE_CHAIN (constructor_fields);
4340
4341       constructor_unfilled_fields = constructor_fields;
4342       constructor_bit_index = bitsize_zero_node;
4343     }
4344   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4345     {
4346       if (TYPE_DOMAIN (constructor_type))
4347         {
4348           constructor_max_index
4349             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4350
4351           /* Detect non-empty initializations of zero-length arrays.  */
4352           if (constructor_max_index == NULL_TREE
4353               && TYPE_SIZE (constructor_type))
4354             constructor_max_index = build_int_2 (-1, -1);
4355
4356           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4357              to initialize VLAs will cause a proper error; avoid tree
4358              checking errors as well by setting a safe value.  */
4359           if (constructor_max_index
4360               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4361             constructor_max_index = build_int_2 (-1, -1);
4362
4363           constructor_index
4364             = convert (bitsizetype,
4365                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4366         }
4367       else
4368         constructor_index = bitsize_zero_node;
4369
4370       constructor_unfilled_index = constructor_index;
4371     }
4372   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4373     {
4374       /* Vectors are like simple fixed-size arrays.  */
4375       constructor_max_index =
4376         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4377       constructor_index = convert (bitsizetype, bitsize_zero_node);
4378       constructor_unfilled_index = constructor_index;
4379     }
4380   else
4381     {
4382       /* Handle the case of int x = {5}; */
4383       constructor_fields = constructor_type;
4384       constructor_unfilled_fields = constructor_type;
4385     }
4386 }
4387 \f
4388 /* Push down into a subobject, for initialization.
4389    If this is for an explicit set of braces, IMPLICIT is 0.
4390    If it is because the next element belongs at a lower level,
4391    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4392
4393 void
4394 push_init_level (int implicit)
4395 {
4396   struct constructor_stack *p;
4397   tree value = NULL_TREE;
4398
4399   /* If we've exhausted any levels that didn't have braces,
4400      pop them now.  */
4401   while (constructor_stack->implicit)
4402     {
4403       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4404            || TREE_CODE (constructor_type) == UNION_TYPE)
4405           && constructor_fields == 0)
4406         process_init_element (pop_init_level (1));
4407       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4408                && constructor_max_index
4409                && tree_int_cst_lt (constructor_max_index, constructor_index))
4410         process_init_element (pop_init_level (1));
4411       else
4412         break;
4413     }
4414
4415   /* Unless this is an explicit brace, we need to preserve previous
4416      content if any.  */
4417   if (implicit)
4418     {
4419       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4420            || TREE_CODE (constructor_type) == UNION_TYPE)
4421           && constructor_fields)
4422         value = find_init_member (constructor_fields);
4423       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4424         value = find_init_member (constructor_index);
4425     }
4426
4427   p = xmalloc (sizeof (struct constructor_stack));
4428   p->type = constructor_type;
4429   p->fields = constructor_fields;
4430   p->index = constructor_index;
4431   p->max_index = constructor_max_index;
4432   p->unfilled_index = constructor_unfilled_index;
4433   p->unfilled_fields = constructor_unfilled_fields;
4434   p->bit_index = constructor_bit_index;
4435   p->elements = constructor_elements;
4436   p->constant = constructor_constant;
4437   p->simple = constructor_simple;
4438   p->erroneous = constructor_erroneous;
4439   p->pending_elts = constructor_pending_elts;
4440   p->depth = constructor_depth;
4441   p->replacement_value = 0;
4442   p->implicit = implicit;
4443   p->outer = 0;
4444   p->incremental = constructor_incremental;
4445   p->designated = constructor_designated;
4446   p->next = constructor_stack;
4447   p->range_stack = 0;
4448   constructor_stack = p;
4449
4450   constructor_constant = 1;
4451   constructor_simple = 1;
4452   constructor_depth = SPELLING_DEPTH ();
4453   constructor_elements = 0;
4454   constructor_incremental = 1;
4455   constructor_designated = 0;
4456   constructor_pending_elts = 0;
4457   if (!implicit)
4458     {
4459       p->range_stack = constructor_range_stack;
4460       constructor_range_stack = 0;
4461       designator_depth = 0;
4462       designator_errorneous = 0;
4463     }
4464
4465   /* Don't die if an entire brace-pair level is superfluous
4466      in the containing level.  */
4467   if (constructor_type == 0)
4468     ;
4469   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4470            || TREE_CODE (constructor_type) == UNION_TYPE)
4471     {
4472       /* Don't die if there are extra init elts at the end.  */
4473       if (constructor_fields == 0)
4474         constructor_type = 0;
4475       else
4476         {
4477           constructor_type = TREE_TYPE (constructor_fields);
4478           push_member_name (constructor_fields);
4479           constructor_depth++;
4480         }
4481     }
4482   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4483     {
4484       constructor_type = TREE_TYPE (constructor_type);
4485       push_array_bounds (tree_low_cst (constructor_index, 0));
4486       constructor_depth++;
4487     }
4488
4489   if (constructor_type == 0)
4490     {
4491       error_init ("extra brace group at end of initializer");
4492       constructor_fields = 0;
4493       constructor_unfilled_fields = 0;
4494       return;
4495     }
4496
4497   if (value && TREE_CODE (value) == CONSTRUCTOR)
4498     {
4499       constructor_constant = TREE_CONSTANT (value);
4500       constructor_simple = TREE_STATIC (value);
4501       constructor_elements = CONSTRUCTOR_ELTS (value);
4502       if (constructor_elements
4503           && (TREE_CODE (constructor_type) == RECORD_TYPE
4504               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4505         set_nonincremental_init ();
4506     }
4507
4508   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4509     {
4510       missing_braces_mentioned = 1;
4511       warning_init ("missing braces around initializer");
4512     }
4513
4514   if (TREE_CODE (constructor_type) == RECORD_TYPE
4515            || TREE_CODE (constructor_type) == UNION_TYPE)
4516     {
4517       constructor_fields = TYPE_FIELDS (constructor_type);
4518       /* Skip any nameless bit fields at the beginning.  */
4519       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4520              && DECL_NAME (constructor_fields) == 0)
4521         constructor_fields = TREE_CHAIN (constructor_fields);
4522
4523       constructor_unfilled_fields = constructor_fields;
4524       constructor_bit_index = bitsize_zero_node;
4525     }
4526   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4527     {
4528       /* Vectors are like simple fixed-size arrays.  */
4529       constructor_max_index =
4530         build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4531       constructor_index = convert (bitsizetype, integer_zero_node);
4532       constructor_unfilled_index = constructor_index;
4533     }
4534   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4535     {
4536       if (TYPE_DOMAIN (constructor_type))
4537         {
4538           constructor_max_index
4539             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4540
4541           /* Detect non-empty initializations of zero-length arrays.  */
4542           if (constructor_max_index == NULL_TREE
4543               && TYPE_SIZE (constructor_type))
4544             constructor_max_index = build_int_2 (-1, -1);
4545
4546           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4547              to initialize VLAs will cause a proper error; avoid tree
4548              checking errors as well by setting a safe value.  */
4549           if (constructor_max_index
4550               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4551             constructor_max_index = build_int_2 (-1, -1);
4552
4553           constructor_index
4554             = convert (bitsizetype,
4555                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4556         }
4557       else
4558         constructor_index = bitsize_zero_node;
4559
4560       constructor_unfilled_index = constructor_index;
4561       if (value && TREE_CODE (value) == STRING_CST)
4562         {
4563           /* We need to split the char/wchar array into individual
4564              characters, so that we don't have to special case it
4565              everywhere.  */
4566           set_nonincremental_init_from_string (value);
4567         }
4568     }
4569   else
4570     {
4571       warning_init ("braces around scalar initializer");
4572       constructor_fields = constructor_type;
4573       constructor_unfilled_fields = constructor_type;
4574     }
4575 }
4576
4577 /* At the end of an implicit or explicit brace level,
4578    finish up that level of constructor.
4579    If we were outputting the elements as they are read, return 0
4580    from inner levels (process_init_element ignores that),
4581    but return error_mark_node from the outermost level
4582    (that's what we want to put in DECL_INITIAL).
4583    Otherwise, return a CONSTRUCTOR expression.  */
4584
4585 tree
4586 pop_init_level (int implicit)
4587 {
4588   struct constructor_stack *p;
4589   tree constructor = 0;
4590
4591   if (implicit == 0)
4592     {
4593       /* When we come to an explicit close brace,
4594          pop any inner levels that didn't have explicit braces.  */
4595       while (constructor_stack->implicit)
4596         process_init_element (pop_init_level (1));
4597
4598       if (constructor_range_stack)
4599         abort ();
4600     }
4601
4602   p = constructor_stack;
4603
4604   /* Error for initializing a flexible array member, or a zero-length
4605      array member in an inappropriate context.  */
4606   if (constructor_type && constructor_fields
4607       && TREE_CODE (constructor_type) == ARRAY_TYPE
4608       && TYPE_DOMAIN (constructor_type)
4609       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4610     {
4611       /* Silently discard empty initializations.  The parser will
4612          already have pedwarned for empty brackets.  */
4613       if (integer_zerop (constructor_unfilled_index))
4614         constructor_type = NULL_TREE;
4615       else if (! TYPE_SIZE (constructor_type))
4616         {
4617           if (constructor_depth > 2)
4618             error_init ("initialization of flexible array member in a nested context");
4619           else if (pedantic)
4620             pedwarn_init ("initialization of a flexible array member");
4621
4622           /* We have already issued an error message for the existence
4623              of a flexible array member not at the end of the structure.
4624              Discard the initializer so that we do not abort later.  */
4625           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4626             constructor_type = NULL_TREE;
4627         }
4628       else
4629         /* Zero-length arrays are no longer special, so we should no longer
4630            get here.  */
4631         abort ();
4632     }
4633
4634   /* Warn when some struct elements are implicitly initialized to zero.  */
4635   if (extra_warnings
4636       && constructor_type
4637       && TREE_CODE (constructor_type) == RECORD_TYPE
4638       && constructor_unfilled_fields)
4639     {
4640         /* Do not warn for flexible array members or zero-length arrays.  */
4641         while (constructor_unfilled_fields
4642                && (! DECL_SIZE (constructor_unfilled_fields)
4643                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4644           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4645
4646         /* Do not warn if this level of the initializer uses member
4647            designators; it is likely to be deliberate.  */
4648         if (constructor_unfilled_fields && !constructor_designated)
4649           {
4650             push_member_name (constructor_unfilled_fields);
4651             warning_init ("missing initializer");
4652             RESTORE_SPELLING_DEPTH (constructor_depth);
4653           }
4654     }
4655
4656   /* Now output all pending elements.  */
4657   constructor_incremental = 1;
4658   output_pending_init_elements (1);
4659
4660   /* Pad out the end of the structure.  */
4661   if (p->replacement_value)
4662     /* If this closes a superfluous brace pair,
4663        just pass out the element between them.  */
4664     constructor = p->replacement_value;
4665   else if (constructor_type == 0)
4666     ;
4667   else if (TREE_CODE (constructor_type) != RECORD_TYPE
4668            && TREE_CODE (constructor_type) != UNION_TYPE
4669            && TREE_CODE (constructor_type) != ARRAY_TYPE
4670            && TREE_CODE (constructor_type) != VECTOR_TYPE)
4671     {
4672       /* A nonincremental scalar initializer--just return
4673          the element, after verifying there is just one.  */
4674       if (constructor_elements == 0)
4675         {
4676           if (!constructor_erroneous)
4677             error_init ("empty scalar initializer");
4678           constructor = error_mark_node;
4679         }
4680       else if (TREE_CHAIN (constructor_elements) != 0)
4681         {
4682           error_init ("extra elements in scalar initializer");
4683           constructor = TREE_VALUE (constructor_elements);
4684         }
4685       else
4686         constructor = TREE_VALUE (constructor_elements);
4687     }
4688   else
4689     {
4690       if (constructor_erroneous)
4691         constructor = error_mark_node;
4692       else
4693         {
4694           constructor = build_constructor (constructor_type,
4695                                            nreverse (constructor_elements));
4696           if (constructor_constant)
4697             TREE_CONSTANT (constructor) = 1;
4698           if (constructor_constant && constructor_simple)
4699             TREE_STATIC (constructor) = 1;
4700         }
4701     }
4702
4703   constructor_type = p->type;
4704   constructor_fields = p->fields;
4705   constructor_index = p->index;
4706   constructor_max_index = p->max_index;
4707   constructor_unfilled_index = p->unfilled_index;
4708   constructor_unfilled_fields = p->unfilled_fields;
4709   constructor_bit_index = p->bit_index;
4710   constructor_elements = p->elements;
4711   constructor_constant = p->constant;
4712   constructor_simple = p->simple;
4713   constructor_erroneous = p->erroneous;
4714   constructor_incremental = p->incremental;
4715   constructor_designated = p->designated;
4716   constructor_pending_elts = p->pending_elts;
4717   constructor_depth = p->depth;
4718   if (!p->implicit)
4719     constructor_range_stack = p->range_stack;
4720   RESTORE_SPELLING_DEPTH (constructor_depth);
4721
4722   constructor_stack = p->next;
4723   free (p);
4724
4725   if (constructor == 0)
4726     {
4727       if (constructor_stack == 0)
4728         return error_mark_node;
4729       return NULL_TREE;
4730     }
4731   return constructor;
4732 }
4733
4734 /* Common handling for both array range and field name designators.
4735    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
4736
4737 static int
4738 set_designator (int array)
4739 {
4740   tree subtype;
4741   enum tree_code subcode;
4742
4743   /* Don't die if an entire brace-pair level is superfluous
4744      in the containing level.  */
4745   if (constructor_type == 0)
4746     return 1;
4747
4748   /* If there were errors in this designator list already, bail out silently.  */
4749   if (designator_errorneous)
4750     return 1;
4751
4752   if (!designator_depth)
4753     {
4754       if (constructor_range_stack)
4755         abort ();
4756
4757       /* Designator list starts at the level of closest explicit
4758          braces.  */
4759       while (constructor_stack->implicit)
4760         process_init_element (pop_init_level (1));
4761       constructor_designated = 1;
4762       return 0;
4763     }
4764
4765   if (constructor_no_implicit)
4766     {
4767       error_init ("initialization designators may not nest");
4768       return 1;
4769     }
4770
4771   if (TREE_CODE (constructor_type) == RECORD_TYPE
4772       || TREE_CODE (constructor_type) == UNION_TYPE)
4773     {
4774       subtype = TREE_TYPE (constructor_fields);
4775       if (subtype != error_mark_node)
4776         subtype = TYPE_MAIN_VARIANT (subtype);
4777     }
4778   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4779     {
4780       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
4781     }
4782   else
4783     abort ();
4784
4785   subcode = TREE_CODE (subtype);
4786   if (array && subcode != ARRAY_TYPE)
4787     {
4788       error_init ("array index in non-array initializer");
4789       return 1;
4790     }
4791   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
4792     {
4793       error_init ("field name not in record or union initializer");
4794       return 1;
4795     }
4796
4797   constructor_designated = 1;
4798   push_init_level (2);
4799   return 0;
4800 }
4801
4802 /* If there are range designators in designator list, push a new designator
4803    to constructor_range_stack.  RANGE_END is end of such stack range or
4804    NULL_TREE if there is no range designator at this level.  */
4805
4806 static void
4807 push_range_stack (tree range_end)
4808 {
4809   struct constructor_range_stack *p;
4810
4811   p = ggc_alloc (sizeof (struct constructor_range_stack));
4812   p->prev = constructor_range_stack;
4813   p->next = 0;
4814   p->fields = constructor_fields;
4815   p->range_start = constructor_index;
4816   p->index = constructor_index;
4817   p->stack = constructor_stack;
4818   p->range_end = range_end;
4819   if (constructor_range_stack)
4820     constructor_range_stack->next = p;
4821   constructor_range_stack = p;
4822 }
4823
4824 /* Within an array initializer, specify the next index to be initialized.
4825    FIRST is that index.  If LAST is nonzero, then initialize a range
4826    of indices, running from FIRST through LAST.  */
4827
4828 void
4829 set_init_index (tree first, tree last)
4830 {
4831   if (set_designator (1))
4832     return;
4833
4834   designator_errorneous = 1;
4835
4836   while ((TREE_CODE (first) == NOP_EXPR
4837           || TREE_CODE (first) == CONVERT_EXPR
4838           || TREE_CODE (first) == NON_LVALUE_EXPR)
4839          && (TYPE_MODE (TREE_TYPE (first))
4840              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
4841     first = TREE_OPERAND (first, 0);
4842
4843   if (last)
4844     while ((TREE_CODE (last) == NOP_EXPR
4845             || TREE_CODE (last) == CONVERT_EXPR
4846             || TREE_CODE (last) == NON_LVALUE_EXPR)
4847            && (TYPE_MODE (TREE_TYPE (last))
4848                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
4849       last = TREE_OPERAND (last, 0);
4850
4851   if (TREE_CODE (first) != INTEGER_CST)
4852     error_init ("nonconstant array index in initializer");
4853   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
4854     error_init ("nonconstant array index in initializer");
4855   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
4856     error_init ("array index in non-array initializer");
4857   else if (tree_int_cst_sgn (first) == -1)
4858     error_init ("array index in initializer exceeds array bounds");
4859   else if (constructor_max_index
4860            && tree_int_cst_lt (constructor_max_index, first))
4861     error_init ("array index in initializer exceeds array bounds");
4862   else
4863     {
4864       constructor_index = convert (bitsizetype, first);
4865
4866       if (last)
4867         {
4868           if (tree_int_cst_equal (first, last))
4869             last = 0;
4870           else if (tree_int_cst_lt (last, first))
4871             {
4872               error_init ("empty index range in initializer");
4873               last = 0;
4874             }
4875           else
4876             {
4877               last = convert (bitsizetype, last);
4878               if (constructor_max_index != 0
4879                   && tree_int_cst_lt (constructor_max_index, last))
4880                 {
4881                   error_init ("array index range in initializer exceeds array bounds");
4882                   last = 0;
4883                 }
4884             }
4885         }
4886
4887       designator_depth++;
4888       designator_errorneous = 0;
4889       if (constructor_range_stack || last)
4890         push_range_stack (last);
4891     }
4892 }
4893
4894 /* Within a struct initializer, specify the next field to be initialized.  */
4895
4896 void
4897 set_init_label (tree fieldname)
4898 {
4899   tree tail;
4900
4901   if (set_designator (0))
4902     return;
4903
4904   designator_errorneous = 1;
4905
4906   if (TREE_CODE (constructor_type) != RECORD_TYPE
4907       && TREE_CODE (constructor_type) != UNION_TYPE)
4908     {
4909       error_init ("field name not in record or union initializer");
4910       return;
4911     }
4912
4913   for (tail = TYPE_FIELDS (constructor_type); tail;
4914        tail = TREE_CHAIN (tail))
4915     {
4916       if (DECL_NAME (tail) == fieldname)
4917         break;
4918     }
4919
4920   if (tail == 0)
4921     error ("unknown field `%s' specified in initializer",
4922            IDENTIFIER_POINTER (fieldname));
4923   else
4924     {
4925       constructor_fields = tail;
4926       designator_depth++;
4927       designator_errorneous = 0;
4928       if (constructor_range_stack)
4929         push_range_stack (NULL_TREE);
4930     }
4931 }
4932 \f
4933 /* Add a new initializer to the tree of pending initializers.  PURPOSE
4934    identifies the initializer, either array index or field in a structure.
4935    VALUE is the value of that index or field.  */
4936
4937 static void
4938 add_pending_init (tree purpose, tree value)
4939 {
4940   struct init_node *p, **q, *r;
4941
4942   q = &constructor_pending_elts;
4943   p = 0;
4944
4945   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4946     {
4947       while (*q != 0)
4948         {
4949           p = *q;
4950           if (tree_int_cst_lt (purpose, p->purpose))
4951             q = &p->left;
4952           else if (tree_int_cst_lt (p->purpose, purpose))
4953             q = &p->right;
4954           else
4955             {
4956               if (TREE_SIDE_EFFECTS (p->value))
4957                 warning_init ("initialized field with side-effects overwritten");
4958               p->value = value;
4959               return;
4960             }
4961         }
4962     }
4963   else
4964     {
4965       tree bitpos;
4966
4967       bitpos = bit_position (purpose);
4968       while (*q != NULL)
4969         {
4970           p = *q;
4971           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
4972             q = &p->left;
4973           else if (p->purpose != purpose)
4974             q = &p->right;
4975           else
4976             {
4977               if (TREE_SIDE_EFFECTS (p->value))
4978                 warning_init ("initialized field with side-effects overwritten");
4979               p->value = value;
4980               return;
4981             }
4982         }
4983     }
4984
4985   r = ggc_alloc (sizeof (struct init_node));
4986   r->purpose = purpose;
4987   r->value = value;
4988
4989   *q = r;
4990   r->parent = p;
4991   r->left = 0;
4992   r->right = 0;
4993   r->balance = 0;
4994
4995   while (p)
4996     {
4997       struct init_node *s;
4998
4999       if (r == p->left)
5000         {
5001           if (p->balance == 0)
5002             p->balance = -1;
5003           else if (p->balance < 0)
5004             {
5005               if (r->balance < 0)
5006                 {
5007                   /* L rotation.  */
5008                   p->left = r->right;
5009                   if (p->left)
5010                     p->left->parent = p;
5011                   r->right = p;
5012
5013                   p->balance = 0;
5014                   r->balance = 0;
5015
5016                   s = p->parent;
5017                   p->parent = r;
5018                   r->parent = s;
5019                   if (s)
5020                     {
5021                       if (s->left == p)
5022                         s->left = r;
5023                       else
5024                         s->right = r;
5025                     }
5026                   else
5027                     constructor_pending_elts = r;
5028                 }
5029               else
5030                 {
5031                   /* LR rotation.  */
5032                   struct init_node *t = r->right;
5033
5034                   r->right = t->left;
5035                   if (r->right)
5036                     r->right->parent = r;
5037                   t->left = r;
5038
5039                   p->left = t->right;
5040                   if (p->left)
5041                     p->left->parent = p;
5042                   t->right = p;
5043
5044                   p->balance = t->balance < 0;
5045                   r->balance = -(t->balance > 0);
5046                   t->balance = 0;
5047
5048                   s = p->parent;
5049                   p->parent = t;
5050                   r->parent = t;
5051                   t->parent = s;
5052                   if (s)
5053                     {
5054                       if (s->left == p)
5055                         s->left = t;
5056                       else
5057                         s->right = t;
5058                     }
5059                   else
5060                     constructor_pending_elts = t;
5061                 }
5062               break;
5063             }
5064           else
5065             {
5066               /* p->balance == +1; growth of left side balances the node.  */
5067               p->balance = 0;
5068               break;
5069             }
5070         }
5071       else /* r == p->right */
5072         {
5073           if (p->balance == 0)
5074             /* Growth propagation from right side.  */
5075             p->balance++;
5076           else if (p->balance > 0)
5077             {
5078               if (r->balance > 0)
5079                 {
5080                   /* R rotation.  */
5081                   p->right = r->left;
5082                   if (p->right)
5083                     p->right->parent = p;
5084                   r->left = p;
5085
5086                   p->balance = 0;
5087                   r->balance = 0;
5088
5089                   s = p->parent;
5090                   p->parent = r;
5091                   r->parent = s;
5092                   if (s)
5093                     {
5094                       if (s->left == p)
5095                         s->left = r;
5096                       else
5097                         s->right = r;
5098                     }
5099                   else
5100                     constructor_pending_elts = r;
5101                 }
5102               else /* r->balance == -1 */
5103                 {
5104                   /* RL rotation */
5105                   struct init_node *t = r->left;
5106
5107                   r->left = t->right;
5108                   if (r->left)
5109                     r->left->parent = r;
5110                   t->right = r;
5111
5112                   p->right = t->left;
5113                   if (p->right)
5114                     p->right->parent = p;
5115                   t->left = p;
5116
5117                   r->balance = (t->balance < 0);
5118                   p->balance = -(t->balance > 0);
5119                   t->balance = 0;
5120
5121                   s = p->parent;
5122                   p->parent = t;
5123                   r->parent = t;
5124                   t->parent = s;
5125                   if (s)
5126                     {
5127                       if (s->left == p)
5128                         s->left = t;
5129                       else
5130                         s->right = t;
5131                     }
5132                   else
5133                     constructor_pending_elts = t;
5134                 }
5135               break;
5136             }
5137           else
5138             {
5139               /* p->balance == -1; growth of right side balances the node.  */
5140               p->balance = 0;
5141               break;
5142             }
5143         }
5144
5145       r = p;
5146       p = p->parent;
5147     }
5148 }
5149
5150 /* Build AVL tree from a sorted chain.  */
5151
5152 static void
5153 set_nonincremental_init (void)
5154 {
5155   tree chain;
5156
5157   if (TREE_CODE (constructor_type) != RECORD_TYPE
5158       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5159     return;
5160
5161   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5162     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5163   constructor_elements = 0;
5164   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5165     {
5166       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5167       /* Skip any nameless bit fields at the beginning.  */
5168       while (constructor_unfilled_fields != 0
5169              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5170              && DECL_NAME (constructor_unfilled_fields) == 0)
5171         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5172
5173     }
5174   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5175     {
5176       if (TYPE_DOMAIN (constructor_type))
5177         constructor_unfilled_index
5178             = convert (bitsizetype,
5179                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5180       else
5181         constructor_unfilled_index = bitsize_zero_node;
5182     }
5183   constructor_incremental = 0;
5184 }
5185
5186 /* Build AVL tree from a string constant.  */
5187
5188 static void
5189 set_nonincremental_init_from_string (tree str)
5190 {
5191   tree value, purpose, type;
5192   HOST_WIDE_INT val[2];
5193   const char *p, *end;
5194   int byte, wchar_bytes, charwidth, bitpos;
5195
5196   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5197     abort ();
5198
5199   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5200       == TYPE_PRECISION (char_type_node))
5201     wchar_bytes = 1;
5202   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5203            == TYPE_PRECISION (wchar_type_node))
5204     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5205   else
5206     abort ();
5207
5208   charwidth = TYPE_PRECISION (char_type_node);
5209   type = TREE_TYPE (constructor_type);
5210   p = TREE_STRING_POINTER (str);
5211   end = p + TREE_STRING_LENGTH (str);
5212
5213   for (purpose = bitsize_zero_node;
5214        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5215        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5216     {
5217       if (wchar_bytes == 1)
5218         {
5219           val[1] = (unsigned char) *p++;
5220           val[0] = 0;
5221         }
5222       else
5223         {
5224           val[0] = 0;
5225           val[1] = 0;
5226           for (byte = 0; byte < wchar_bytes; byte++)
5227             {
5228               if (BYTES_BIG_ENDIAN)
5229                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5230               else
5231                 bitpos = byte * charwidth;
5232               val[bitpos < HOST_BITS_PER_WIDE_INT]
5233                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5234                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5235             }
5236         }
5237
5238       if (!TREE_UNSIGNED (type))
5239         {
5240           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5241           if (bitpos < HOST_BITS_PER_WIDE_INT)
5242             {
5243               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5244                 {
5245                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5246                   val[0] = -1;
5247                 }
5248             }
5249           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5250             {
5251               if (val[1] < 0)
5252                 val[0] = -1;
5253             }
5254           else if (val[0] & (((HOST_WIDE_INT) 1)
5255                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5256             val[0] |= ((HOST_WIDE_INT) -1)
5257                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5258         }
5259
5260       value = build_int_2 (val[1], val[0]);
5261       TREE_TYPE (value) = type;
5262       add_pending_init (purpose, value);
5263     }
5264
5265   constructor_incremental = 0;
5266 }
5267
5268 /* Return value of FIELD in pending initializer or zero if the field was
5269    not initialized yet.  */
5270
5271 static tree
5272 find_init_member (tree field)
5273 {
5274   struct init_node *p;
5275
5276   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5277     {
5278       if (constructor_incremental
5279           && tree_int_cst_lt (field, constructor_unfilled_index))
5280         set_nonincremental_init ();
5281
5282       p = constructor_pending_elts;
5283       while (p)
5284         {
5285           if (tree_int_cst_lt (field, p->purpose))
5286             p = p->left;
5287           else if (tree_int_cst_lt (p->purpose, field))
5288             p = p->right;
5289           else
5290             return p->value;
5291         }
5292     }
5293   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5294     {
5295       tree bitpos = bit_position (field);
5296
5297       if (constructor_incremental
5298           && (!constructor_unfilled_fields
5299               || tree_int_cst_lt (bitpos,
5300                                   bit_position (constructor_unfilled_fields))))
5301         set_nonincremental_init ();
5302
5303       p = constructor_pending_elts;
5304       while (p)
5305         {
5306           if (field == p->purpose)
5307             return p->value;
5308           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5309             p = p->left;
5310           else
5311             p = p->right;
5312         }
5313     }
5314   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5315     {
5316       if (constructor_elements
5317           && TREE_PURPOSE (constructor_elements) == field)
5318         return TREE_VALUE (constructor_elements);
5319     }
5320   return 0;
5321 }
5322
5323 /* "Output" the next constructor element.
5324    At top level, really output it to assembler code now.
5325    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5326    TYPE is the data type that the containing data type wants here.
5327    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5328
5329    PENDING if non-nil means output pending elements that belong
5330    right after this element.  (PENDING is normally 1;
5331    it is 0 while outputting pending elements, to avoid recursion.)  */
5332
5333 static void
5334 output_init_element (tree value, tree type, tree field, int pending)
5335 {
5336   if (type == error_mark_node)
5337     {
5338       constructor_erroneous = 1;
5339       return;
5340     }
5341   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5342       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5343           && !(TREE_CODE (value) == STRING_CST
5344                && TREE_CODE (type) == ARRAY_TYPE
5345                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5346           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5347                          TYPE_MAIN_VARIANT (type), COMPARE_STRICT)))
5348     value = default_conversion (value);
5349
5350   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5351       && require_constant_value && !flag_isoc99 && pending)
5352     {
5353       /* As an extension, allow initializing objects with static storage
5354          duration with compound literals (which are then treated just as
5355          the brace enclosed list they contain).  */
5356       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5357       value = DECL_INITIAL (decl);
5358     }
5359
5360   if (value == error_mark_node)
5361     constructor_erroneous = 1;
5362   else if (!TREE_CONSTANT (value))
5363     constructor_constant = 0;
5364   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5365            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5366                 || TREE_CODE (constructor_type) == UNION_TYPE)
5367                && DECL_C_BIT_FIELD (field)
5368                && TREE_CODE (value) != INTEGER_CST))
5369     constructor_simple = 0;
5370
5371   if (require_constant_value && ! TREE_CONSTANT (value))
5372     {
5373       error_init ("initializer element is not constant");
5374       value = error_mark_node;
5375     }
5376   else if (require_constant_elements
5377            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5378     pedwarn ("initializer element is not computable at load time");
5379
5380   /* If this field is empty (and not at the end of structure),
5381      don't do anything other than checking the initializer.  */
5382   if (field
5383       && (TREE_TYPE (field) == error_mark_node
5384           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5385               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5386               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5387                   || TREE_CHAIN (field)))))
5388     return;
5389
5390   value = digest_init (type, value, require_constant_value);
5391   if (value == error_mark_node)
5392     {
5393       constructor_erroneous = 1;
5394       return;
5395     }
5396
5397   /* If this element doesn't come next in sequence,
5398      put it on constructor_pending_elts.  */
5399   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5400       && (!constructor_incremental
5401           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5402     {
5403       if (constructor_incremental
5404           && tree_int_cst_lt (field, constructor_unfilled_index))
5405         set_nonincremental_init ();
5406
5407       add_pending_init (field, value);
5408       return;
5409     }
5410   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5411            && (!constructor_incremental
5412                || field != constructor_unfilled_fields))
5413     {
5414       /* We do this for records but not for unions.  In a union,
5415          no matter which field is specified, it can be initialized
5416          right away since it starts at the beginning of the union.  */
5417       if (constructor_incremental)
5418         {
5419           if (!constructor_unfilled_fields)
5420             set_nonincremental_init ();
5421           else
5422             {
5423               tree bitpos, unfillpos;
5424
5425               bitpos = bit_position (field);
5426               unfillpos = bit_position (constructor_unfilled_fields);
5427
5428               if (tree_int_cst_lt (bitpos, unfillpos))
5429                 set_nonincremental_init ();
5430             }
5431         }
5432
5433       add_pending_init (field, value);
5434       return;
5435     }
5436   else if (TREE_CODE (constructor_type) == UNION_TYPE
5437            && constructor_elements)
5438     {
5439       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5440         warning_init ("initialized field with side-effects overwritten");
5441
5442       /* We can have just one union field set.  */
5443       constructor_elements = 0;
5444     }
5445
5446   /* Otherwise, output this element either to
5447      constructor_elements or to the assembler file.  */
5448
5449   if (field && TREE_CODE (field) == INTEGER_CST)
5450     field = copy_node (field);
5451   constructor_elements
5452     = tree_cons (field, value, constructor_elements);
5453
5454   /* Advance the variable that indicates sequential elements output.  */
5455   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5456     constructor_unfilled_index
5457       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5458                     bitsize_one_node);
5459   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5460     {
5461       constructor_unfilled_fields
5462         = TREE_CHAIN (constructor_unfilled_fields);
5463
5464       /* Skip any nameless bit fields.  */
5465       while (constructor_unfilled_fields != 0
5466              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5467              && DECL_NAME (constructor_unfilled_fields) == 0)
5468         constructor_unfilled_fields =
5469           TREE_CHAIN (constructor_unfilled_fields);
5470     }
5471   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5472     constructor_unfilled_fields = 0;
5473
5474   /* Now output any pending elements which have become next.  */
5475   if (pending)
5476     output_pending_init_elements (0);
5477 }
5478
5479 /* Output any pending elements which have become next.
5480    As we output elements, constructor_unfilled_{fields,index}
5481    advances, which may cause other elements to become next;
5482    if so, they too are output.
5483
5484    If ALL is 0, we return when there are
5485    no more pending elements to output now.
5486
5487    If ALL is 1, we output space as necessary so that
5488    we can output all the pending elements.  */
5489
5490 static void
5491 output_pending_init_elements (int all)
5492 {
5493   struct init_node *elt = constructor_pending_elts;
5494   tree next;
5495
5496  retry:
5497
5498   /* Look through the whole pending tree.
5499      If we find an element that should be output now,
5500      output it.  Otherwise, set NEXT to the element
5501      that comes first among those still pending.  */
5502
5503   next = 0;
5504   while (elt)
5505     {
5506       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5507         {
5508           if (tree_int_cst_equal (elt->purpose,
5509                                   constructor_unfilled_index))
5510             output_init_element (elt->value,
5511                                  TREE_TYPE (constructor_type),
5512                                  constructor_unfilled_index, 0);
5513           else if (tree_int_cst_lt (constructor_unfilled_index,
5514                                     elt->purpose))
5515             {
5516               /* Advance to the next smaller node.  */
5517               if (elt->left)
5518                 elt = elt->left;
5519               else
5520                 {
5521                   /* We have reached the smallest node bigger than the
5522                      current unfilled index.  Fill the space first.  */
5523                   next = elt->purpose;
5524                   break;
5525                 }
5526             }
5527           else
5528             {
5529               /* Advance to the next bigger node.  */
5530               if (elt->right)
5531                 elt = elt->right;
5532               else
5533                 {
5534                   /* We have reached the biggest node in a subtree.  Find
5535                      the parent of it, which is the next bigger node.  */
5536                   while (elt->parent && elt->parent->right == elt)
5537                     elt = elt->parent;
5538                   elt = elt->parent;
5539                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5540                                               elt->purpose))
5541                     {
5542                       next = elt->purpose;
5543                       break;
5544                     }
5545                 }
5546             }
5547         }
5548       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5549                || TREE_CODE (constructor_type) == UNION_TYPE)
5550         {
5551           tree ctor_unfilled_bitpos, elt_bitpos;
5552
5553           /* If the current record is complete we are done.  */
5554           if (constructor_unfilled_fields == 0)
5555             break;
5556
5557           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5558           elt_bitpos = bit_position (elt->purpose);
5559           /* We can't compare fields here because there might be empty
5560              fields in between.  */
5561           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5562             {
5563               constructor_unfilled_fields = elt->purpose;
5564               output_init_element (elt->value, TREE_TYPE (elt->purpose),
5565                                    elt->purpose, 0);
5566             }
5567           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5568             {
5569               /* Advance to the next smaller node.  */
5570               if (elt->left)
5571                 elt = elt->left;
5572               else
5573                 {
5574                   /* We have reached the smallest node bigger than the
5575                      current unfilled field.  Fill the space first.  */
5576                   next = elt->purpose;
5577                   break;
5578                 }
5579             }
5580           else
5581             {
5582               /* Advance to the next bigger node.  */
5583               if (elt->right)
5584                 elt = elt->right;
5585               else
5586                 {
5587                   /* We have reached the biggest node in a subtree.  Find
5588                      the parent of it, which is the next bigger node.  */
5589                   while (elt->parent && elt->parent->right == elt)
5590                     elt = elt->parent;
5591                   elt = elt->parent;
5592                   if (elt
5593                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5594                                            bit_position (elt->purpose))))
5595                     {
5596                       next = elt->purpose;
5597                       break;
5598                     }
5599                 }
5600             }
5601         }
5602     }
5603
5604   /* Ordinarily return, but not if we want to output all
5605      and there are elements left.  */
5606   if (! (all && next != 0))
5607     return;
5608
5609   /* If it's not incremental, just skip over the gap, so that after
5610      jumping to retry we will output the next successive element.  */
5611   if (TREE_CODE (constructor_type) == RECORD_TYPE
5612       || TREE_CODE (constructor_type) == UNION_TYPE)
5613     constructor_unfilled_fields = next;
5614   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5615     constructor_unfilled_index = next;
5616
5617   /* ELT now points to the node in the pending tree with the next
5618      initializer to output.  */
5619   goto retry;
5620 }
5621 \f
5622 /* Add one non-braced element to the current constructor level.
5623    This adjusts the current position within the constructor's type.
5624    This may also start or terminate implicit levels
5625    to handle a partly-braced initializer.
5626
5627    Once this has found the correct level for the new element,
5628    it calls output_init_element.  */
5629
5630 void
5631 process_init_element (tree value)
5632 {
5633   tree orig_value = value;
5634   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
5635
5636   designator_depth = 0;
5637   designator_errorneous = 0;
5638
5639   /* Handle superfluous braces around string cst as in
5640      char x[] = {"foo"}; */
5641   if (string_flag
5642       && constructor_type
5643       && TREE_CODE (constructor_type) == ARRAY_TYPE
5644       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
5645       && integer_zerop (constructor_unfilled_index))
5646     {
5647       if (constructor_stack->replacement_value)
5648         error_init ("excess elements in char array initializer");
5649       constructor_stack->replacement_value = value;
5650       return;
5651     }
5652
5653   if (constructor_stack->replacement_value != 0)
5654     {
5655       error_init ("excess elements in struct initializer");
5656       return;
5657     }
5658
5659   /* Ignore elements of a brace group if it is entirely superfluous
5660      and has already been diagnosed.  */
5661   if (constructor_type == 0)
5662     return;
5663
5664   /* If we've exhausted any levels that didn't have braces,
5665      pop them now.  */
5666   while (constructor_stack->implicit)
5667     {
5668       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5669            || TREE_CODE (constructor_type) == UNION_TYPE)
5670           && constructor_fields == 0)
5671         process_init_element (pop_init_level (1));
5672       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5673                && (constructor_max_index == 0
5674                    || tree_int_cst_lt (constructor_max_index,
5675                                        constructor_index)))
5676         process_init_element (pop_init_level (1));
5677       else
5678         break;
5679     }
5680
5681   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
5682   if (constructor_range_stack)
5683     {
5684       /* If value is a compound literal and we'll be just using its
5685          content, don't put it into a SAVE_EXPR.  */
5686       if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
5687           || !require_constant_value
5688           || flag_isoc99)
5689         value = save_expr (value);
5690     }
5691
5692   while (1)
5693     {
5694       if (TREE_CODE (constructor_type) == RECORD_TYPE)
5695         {
5696           tree fieldtype;
5697           enum tree_code fieldcode;
5698
5699           if (constructor_fields == 0)
5700             {
5701               pedwarn_init ("excess elements in struct initializer");
5702               break;
5703             }
5704
5705           fieldtype = TREE_TYPE (constructor_fields);
5706           if (fieldtype != error_mark_node)
5707             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5708           fieldcode = TREE_CODE (fieldtype);
5709
5710           /* Error for non-static initialization of a flexible array member.  */
5711           if (fieldcode == ARRAY_TYPE
5712               && !require_constant_value
5713               && TYPE_SIZE (fieldtype) == NULL_TREE
5714               && TREE_CHAIN (constructor_fields) == NULL_TREE)
5715             {
5716               error_init ("non-static initialization of a flexible array member");
5717               break;
5718             }
5719
5720           /* Accept a string constant to initialize a subarray.  */
5721           if (value != 0
5722               && fieldcode == ARRAY_TYPE
5723               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5724               && string_flag)
5725             value = orig_value;
5726           /* Otherwise, if we have come to a subaggregate,
5727              and we don't have an element of its type, push into it.  */
5728           else if (value != 0 && !constructor_no_implicit
5729                    && value != error_mark_node
5730                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5731                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5732                        || fieldcode == UNION_TYPE))
5733             {
5734               push_init_level (1);
5735               continue;
5736             }
5737
5738           if (value)
5739             {
5740               push_member_name (constructor_fields);
5741               output_init_element (value, fieldtype, constructor_fields, 1);
5742               RESTORE_SPELLING_DEPTH (constructor_depth);
5743             }
5744           else
5745             /* Do the bookkeeping for an element that was
5746                directly output as a constructor.  */
5747             {
5748               /* For a record, keep track of end position of last field.  */
5749               if (DECL_SIZE (constructor_fields))
5750                 constructor_bit_index
5751                   = size_binop (PLUS_EXPR,
5752                                 bit_position (constructor_fields),
5753                                 DECL_SIZE (constructor_fields));
5754
5755               /* If the current field was the first one not yet written out,
5756                  it isn't now, so update.  */
5757               if (constructor_unfilled_fields == constructor_fields)
5758                 {
5759                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5760                   /* Skip any nameless bit fields.  */
5761                   while (constructor_unfilled_fields != 0
5762                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5763                          && DECL_NAME (constructor_unfilled_fields) == 0)
5764                     constructor_unfilled_fields =
5765                       TREE_CHAIN (constructor_unfilled_fields);
5766                 }
5767             }
5768
5769           constructor_fields = TREE_CHAIN (constructor_fields);
5770           /* Skip any nameless bit fields at the beginning.  */
5771           while (constructor_fields != 0
5772                  && DECL_C_BIT_FIELD (constructor_fields)
5773                  && DECL_NAME (constructor_fields) == 0)
5774             constructor_fields = TREE_CHAIN (constructor_fields);
5775         }
5776       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5777         {
5778           tree fieldtype;
5779           enum tree_code fieldcode;
5780
5781           if (constructor_fields == 0)
5782             {
5783               pedwarn_init ("excess elements in union initializer");
5784               break;
5785             }
5786
5787           fieldtype = TREE_TYPE (constructor_fields);
5788           if (fieldtype != error_mark_node)
5789             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5790           fieldcode = TREE_CODE (fieldtype);
5791
5792           /* Warn that traditional C rejects initialization of unions.
5793              We skip the warning if the value is zero.  This is done
5794              under the assumption that the zero initializer in user
5795              code appears conditioned on e.g. __STDC__ to avoid
5796              "missing initializer" warnings and relies on default
5797              initialization to zero in the traditional C case.
5798              We also skip the warning if the initializer is designated,
5799              again on the assumption that this must be conditional on
5800              __STDC__ anyway (and we've already complained about the
5801              member-designator already).  */
5802           if (warn_traditional && !in_system_header && !constructor_designated
5803               && !(value && (integer_zerop (value) || real_zerop (value))))
5804             warning ("traditional C rejects initialization of unions");
5805
5806           /* Accept a string constant to initialize a subarray.  */
5807           if (value != 0
5808               && fieldcode == ARRAY_TYPE
5809               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5810               && string_flag)
5811             value = orig_value;
5812           /* Otherwise, if we have come to a subaggregate,
5813              and we don't have an element of its type, push into it.  */
5814           else if (value != 0 && !constructor_no_implicit
5815                    && value != error_mark_node
5816                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5817                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5818                        || fieldcode == UNION_TYPE))
5819             {
5820               push_init_level (1);
5821               continue;
5822             }
5823
5824           if (value)
5825             {
5826               push_member_name (constructor_fields);
5827               output_init_element (value, fieldtype, constructor_fields, 1);
5828               RESTORE_SPELLING_DEPTH (constructor_depth);
5829             }
5830           else
5831             /* Do the bookkeeping for an element that was
5832                directly output as a constructor.  */
5833             {
5834               constructor_bit_index = DECL_SIZE (constructor_fields);
5835               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5836             }
5837
5838           constructor_fields = 0;
5839         }
5840       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5841         {
5842           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5843           enum tree_code eltcode = TREE_CODE (elttype);
5844
5845           /* Accept a string constant to initialize a subarray.  */
5846           if (value != 0
5847               && eltcode == ARRAY_TYPE
5848               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
5849               && string_flag)
5850             value = orig_value;
5851           /* Otherwise, if we have come to a subaggregate,
5852              and we don't have an element of its type, push into it.  */
5853           else if (value != 0 && !constructor_no_implicit
5854                    && value != error_mark_node
5855                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
5856                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
5857                        || eltcode == UNION_TYPE))
5858             {
5859               push_init_level (1);
5860               continue;
5861             }
5862
5863           if (constructor_max_index != 0
5864               && (tree_int_cst_lt (constructor_max_index, constructor_index)
5865                   || integer_all_onesp (constructor_max_index)))
5866             {
5867               pedwarn_init ("excess elements in array initializer");
5868               break;
5869             }
5870
5871           /* Now output the actual element.  */
5872           if (value)
5873             {
5874               push_array_bounds (tree_low_cst (constructor_index, 0));
5875               output_init_element (value, elttype, constructor_index, 1);
5876               RESTORE_SPELLING_DEPTH (constructor_depth);
5877             }
5878
5879           constructor_index
5880             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
5881
5882           if (! value)
5883             /* If we are doing the bookkeeping for an element that was
5884                directly output as a constructor, we must update
5885                constructor_unfilled_index.  */
5886             constructor_unfilled_index = constructor_index;
5887         }
5888       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5889         {
5890           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5891
5892          /* Do a basic check of initializer size.  Note that vectors
5893             always have a fixed size derived from their type.  */
5894           if (tree_int_cst_lt (constructor_max_index, constructor_index))
5895             {
5896               pedwarn_init ("excess elements in vector initializer");
5897               break;
5898             }
5899
5900           /* Now output the actual element.  */
5901           if (value)
5902             output_init_element (value, elttype, constructor_index, 1);
5903
5904           constructor_index
5905             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
5906
5907           if (! value)
5908             /* If we are doing the bookkeeping for an element that was
5909                directly output as a constructor, we must update
5910                constructor_unfilled_index.  */
5911             constructor_unfilled_index = constructor_index;
5912         }
5913
5914       /* Handle the sole element allowed in a braced initializer
5915          for a scalar variable.  */
5916       else if (constructor_fields == 0)
5917         {
5918           pedwarn_init ("excess elements in scalar initializer");
5919           break;
5920         }
5921       else
5922         {
5923           if (value)
5924             output_init_element (value, constructor_type, NULL_TREE, 1);
5925           constructor_fields = 0;
5926         }
5927
5928       /* Handle range initializers either at this level or anywhere higher
5929          in the designator stack.  */
5930       if (constructor_range_stack)
5931         {
5932           struct constructor_range_stack *p, *range_stack;
5933           int finish = 0;
5934
5935           range_stack = constructor_range_stack;
5936           constructor_range_stack = 0;
5937           while (constructor_stack != range_stack->stack)
5938             {
5939               if (!constructor_stack->implicit)
5940                 abort ();
5941               process_init_element (pop_init_level (1));
5942             }
5943           for (p = range_stack;
5944                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
5945                p = p->prev)
5946             {
5947               if (!constructor_stack->implicit)
5948                 abort ();
5949               process_init_element (pop_init_level (1));
5950             }
5951
5952           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
5953           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
5954             finish = 1;
5955
5956           while (1)
5957             {
5958               constructor_index = p->index;
5959               constructor_fields = p->fields;
5960               if (finish && p->range_end && p->index == p->range_start)
5961                 {
5962                   finish = 0;
5963                   p->prev = 0;
5964                 }
5965               p = p->next;
5966               if (!p)
5967                 break;
5968               push_init_level (2);
5969               p->stack = constructor_stack;
5970               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
5971                 p->index = p->range_start;
5972             }
5973
5974           if (!finish)
5975             constructor_range_stack = range_stack;
5976           continue;
5977         }
5978
5979       break;
5980     }
5981
5982   constructor_range_stack = 0;
5983 }
5984 \f
5985 /* Build a simple asm-statement, from one string literal.  */
5986 tree
5987 simple_asm_stmt (tree expr)
5988 {
5989   STRIP_NOPS (expr);
5990
5991   if (TREE_CODE (expr) == ADDR_EXPR)
5992     expr = TREE_OPERAND (expr, 0);
5993
5994   if (TREE_CODE (expr) == STRING_CST)
5995     {
5996       tree stmt;
5997
5998       /* Simple asm statements are treated as volatile.  */
5999       stmt = add_stmt (build_stmt (ASM_STMT, ridpointers[(int) RID_VOLATILE],
6000                                    expr, NULL_TREE, NULL_TREE, NULL_TREE));
6001       ASM_INPUT_P (stmt) = 1;
6002       return stmt;
6003     }
6004
6005   error ("argument of `asm' is not a constant string");
6006   return NULL_TREE;
6007 }
6008
6009 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6010    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6011
6012 tree
6013 build_asm_stmt (tree cv_qualifier, tree string, tree outputs, tree inputs,
6014                 tree clobbers)
6015 {
6016   tree tail;
6017
6018   if (TREE_CODE (string) != STRING_CST)
6019     {
6020       error ("asm template is not a string constant");
6021       return NULL_TREE;
6022     }
6023
6024   if (cv_qualifier != NULL_TREE
6025       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6026     {
6027       warning ("%s qualifier ignored on asm",
6028                IDENTIFIER_POINTER (cv_qualifier));
6029       cv_qualifier = NULL_TREE;
6030     }
6031
6032   /* We can remove output conversions that change the type,
6033      but not the mode.  */
6034   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6035     {
6036       tree output = TREE_VALUE (tail);
6037
6038       STRIP_NOPS (output);
6039       TREE_VALUE (tail) = output;
6040
6041       /* Allow conversions as LHS here.  build_modify_expr as called below
6042          will do the right thing with them.  */
6043       while (TREE_CODE (output) == NOP_EXPR
6044              || TREE_CODE (output) == CONVERT_EXPR
6045              || TREE_CODE (output) == FLOAT_EXPR
6046              || TREE_CODE (output) == FIX_TRUNC_EXPR
6047              || TREE_CODE (output) == FIX_FLOOR_EXPR
6048              || TREE_CODE (output) == FIX_ROUND_EXPR
6049              || TREE_CODE (output) == FIX_CEIL_EXPR)
6050         output = TREE_OPERAND (output, 0);
6051
6052       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6053     }
6054
6055   /* Remove output conversions that change the type but not the mode.  */
6056   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6057     {
6058       tree output = TREE_VALUE (tail);
6059       STRIP_NOPS (output);
6060       TREE_VALUE (tail) = output;
6061     }
6062
6063   /* Perform default conversions on array and function inputs.
6064      Don't do this for other types as it would screw up operands
6065      expected to be in memory.  */
6066   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6067     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6068
6069   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6070                                outputs, inputs, clobbers));
6071 }
6072
6073 /* Expand an ASM statement with operands, handling output operands
6074    that are not variables or INDIRECT_REFS by transforming such
6075    cases into cases that expand_asm_operands can handle.
6076
6077    Arguments are same as for expand_asm_operands.  */
6078
6079 void
6080 c_expand_asm_operands (tree string, tree outputs, tree inputs,
6081                        tree clobbers, int vol, location_t locus)
6082 {
6083   int noutputs = list_length (outputs);
6084   int i;
6085   /* o[I] is the place that output number I should be written.  */
6086   tree *o = alloca (noutputs * sizeof (tree));
6087   tree tail;
6088
6089   /* Record the contents of OUTPUTS before it is modified.  */
6090   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6091     {
6092       o[i] = TREE_VALUE (tail);
6093       if (o[i] == error_mark_node)
6094         return;
6095     }
6096
6097   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6098      OUTPUTS some trees for where the values were actually stored.  */
6099   expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
6100
6101   /* Copy all the intermediate outputs into the specified outputs.  */
6102   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6103     {
6104       if (o[i] != TREE_VALUE (tail))
6105         {
6106           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6107                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6108           free_temp_slots ();
6109
6110           /* Restore the original value so that it's correct the next
6111              time we expand this function.  */
6112           TREE_VALUE (tail) = o[i];
6113         }
6114       /* Detect modification of read-only values.
6115          (Otherwise done by build_modify_expr.)  */
6116       else
6117         {
6118           tree type = TREE_TYPE (o[i]);
6119           if (TREE_READONLY (o[i])
6120               || TYPE_READONLY (type)
6121               || ((TREE_CODE (type) == RECORD_TYPE
6122                    || TREE_CODE (type) == UNION_TYPE)
6123                   && C_TYPE_FIELDS_READONLY (type)))
6124             readonly_warning (o[i], "modification by `asm'");
6125         }
6126     }
6127
6128   /* Those MODIFY_EXPRs could do autoincrements.  */
6129   emit_queue ();
6130 }
6131 \f
6132 /* Expand a C `return' statement.
6133    RETVAL is the expression for what to return,
6134    or a null pointer for `return;' with no value.  */
6135
6136 tree
6137 c_expand_return (tree retval)
6138 {
6139   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6140
6141   if (TREE_THIS_VOLATILE (current_function_decl))
6142     warning ("function declared `noreturn' has a `return' statement");
6143
6144   if (!retval)
6145     {
6146       current_function_returns_null = 1;
6147       if ((warn_return_type || flag_isoc99)
6148           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6149         pedwarn_c99 ("`return' with no value, in function returning non-void");
6150     }
6151   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6152     {
6153       current_function_returns_null = 1;
6154       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6155         pedwarn ("`return' with a value, in function returning void");
6156     }
6157   else
6158     {
6159       tree t = convert_for_assignment (valtype, retval, _("return"),
6160                                        NULL_TREE, NULL_TREE, 0);
6161       tree res = DECL_RESULT (current_function_decl);
6162       tree inner;
6163
6164       current_function_returns_value = 1;
6165       if (t == error_mark_node)
6166         return NULL_TREE;
6167
6168       inner = t = convert (TREE_TYPE (res), t);
6169
6170       /* Strip any conversions, additions, and subtractions, and see if
6171          we are returning the address of a local variable.  Warn if so.  */
6172       while (1)
6173         {
6174           switch (TREE_CODE (inner))
6175             {
6176             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6177             case PLUS_EXPR:
6178               inner = TREE_OPERAND (inner, 0);
6179               continue;
6180
6181             case MINUS_EXPR:
6182               /* If the second operand of the MINUS_EXPR has a pointer
6183                  type (or is converted from it), this may be valid, so
6184                  don't give a warning.  */
6185               {
6186                 tree op1 = TREE_OPERAND (inner, 1);
6187
6188                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6189                        && (TREE_CODE (op1) == NOP_EXPR
6190                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6191                            || TREE_CODE (op1) == CONVERT_EXPR))
6192                   op1 = TREE_OPERAND (op1, 0);
6193
6194                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6195                   break;
6196
6197                 inner = TREE_OPERAND (inner, 0);
6198                 continue;
6199               }
6200
6201             case ADDR_EXPR:
6202               inner = TREE_OPERAND (inner, 0);
6203
6204               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6205                 inner = TREE_OPERAND (inner, 0);
6206
6207               if (TREE_CODE (inner) == VAR_DECL
6208                   && ! DECL_EXTERNAL (inner)
6209                   && ! TREE_STATIC (inner)
6210                   && DECL_CONTEXT (inner) == current_function_decl)
6211                 warning ("function returns address of local variable");
6212               break;
6213
6214             default:
6215               break;
6216             }
6217
6218           break;
6219         }
6220
6221       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6222     }
6223
6224  return add_stmt (build_return_stmt (retval));
6225 }
6226 \f
6227 struct c_switch {
6228   /* The SWITCH_STMT being built.  */
6229   tree switch_stmt;
6230   /* A splay-tree mapping the low element of a case range to the high
6231      element, or NULL_TREE if there is no high element.  Used to
6232      determine whether or not a new case label duplicates an old case
6233      label.  We need a tree, rather than simply a hash table, because
6234      of the GNU case range extension.  */
6235   splay_tree cases;
6236   /* The next node on the stack.  */
6237   struct c_switch *next;
6238 };
6239
6240 /* A stack of the currently active switch statements.  The innermost
6241    switch statement is on the top of the stack.  There is no need to
6242    mark the stack for garbage collection because it is only active
6243    during the processing of the body of a function, and we never
6244    collect at that point.  */
6245
6246 static struct c_switch *switch_stack;
6247
6248 /* Start a C switch statement, testing expression EXP.  Return the new
6249    SWITCH_STMT.  */
6250
6251 tree
6252 c_start_case (tree exp)
6253 {
6254   enum tree_code code;
6255   tree type, orig_type = error_mark_node;
6256   struct c_switch *cs;
6257
6258   if (exp != error_mark_node)
6259     {
6260       code = TREE_CODE (TREE_TYPE (exp));
6261       orig_type = TREE_TYPE (exp);
6262
6263       if (! INTEGRAL_TYPE_P (orig_type)
6264           && code != ERROR_MARK)
6265         {
6266           error ("switch quantity not an integer");
6267           exp = integer_zero_node;
6268         }
6269       else
6270         {
6271           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6272
6273           if (warn_traditional && !in_system_header
6274               && (type == long_integer_type_node
6275                   || type == long_unsigned_type_node))
6276             warning ("`long' switch expression not converted to `int' in ISO C");
6277
6278           exp = default_conversion (exp);
6279           type = TREE_TYPE (exp);
6280         }
6281     }
6282
6283   /* Add this new SWITCH_STMT to the stack.  */
6284   cs = xmalloc (sizeof (*cs));
6285   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
6286   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6287   cs->next = switch_stack;
6288   switch_stack = cs;
6289
6290   return add_stmt (switch_stack->switch_stmt);
6291 }
6292
6293 /* Process a case label.  */
6294
6295 tree
6296 do_case (tree low_value, tree high_value)
6297 {
6298   tree label = NULL_TREE;
6299
6300   if (switch_stack)
6301     {
6302       bool switch_was_empty_p = (SWITCH_BODY (switch_stack->switch_stmt) == NULL_TREE);
6303
6304       label = c_add_case_label (switch_stack->cases,
6305                                 SWITCH_COND (switch_stack->switch_stmt),
6306                                 low_value, high_value);
6307       if (label == error_mark_node)
6308         label = NULL_TREE;
6309       else if (switch_was_empty_p)
6310         {
6311           /* Attach the first case label to the SWITCH_BODY.  */
6312           SWITCH_BODY (switch_stack->switch_stmt) = TREE_CHAIN (switch_stack->switch_stmt);
6313           TREE_CHAIN (switch_stack->switch_stmt) = NULL_TREE;
6314         }
6315     }
6316   else if (low_value)
6317     error ("case label not within a switch statement");
6318   else
6319     error ("`default' label not within a switch statement");
6320
6321   return label;
6322 }
6323
6324 /* Finish the switch statement.  */
6325
6326 void
6327 c_finish_case (void)
6328 {
6329   struct c_switch *cs = switch_stack;
6330
6331   /* Rechain the next statements to the SWITCH_STMT.  */
6332   last_tree = cs->switch_stmt;
6333
6334   /* Pop the stack.  */
6335   switch_stack = switch_stack->next;
6336   splay_tree_delete (cs->cases);
6337   free (cs);
6338 }
6339
6340 /* Build a binary-operation expression without default conversions.
6341    CODE is the kind of expression to build.
6342    This function differs from `build' in several ways:
6343    the data type of the result is computed and recorded in it,
6344    warnings are generated if arg data types are invalid,
6345    special handling for addition and subtraction of pointers is known,
6346    and some optimization is done (operations on narrow ints
6347    are done in the narrower type when that gives the same result).
6348    Constant folding is also done before the result is returned.
6349
6350    Note that the operands will never have enumeral types, or function
6351    or array types, because either they will have the default conversions
6352    performed or they have both just been converted to some other type in which
6353    the arithmetic is to be done.  */
6354
6355 tree
6356 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6357                  int convert_p)
6358 {
6359   tree type0, type1;
6360   enum tree_code code0, code1;
6361   tree op0, op1;
6362
6363   /* Expression code to give to the expression when it is built.
6364      Normally this is CODE, which is what the caller asked for,
6365      but in some special cases we change it.  */
6366   enum tree_code resultcode = code;
6367
6368   /* Data type in which the computation is to be performed.
6369      In the simplest cases this is the common type of the arguments.  */
6370   tree result_type = NULL;
6371
6372   /* Nonzero means operands have already been type-converted
6373      in whatever way is necessary.
6374      Zero means they need to be converted to RESULT_TYPE.  */
6375   int converted = 0;
6376
6377   /* Nonzero means create the expression with this type, rather than
6378      RESULT_TYPE.  */
6379   tree build_type = 0;
6380
6381   /* Nonzero means after finally constructing the expression
6382      convert it to this type.  */
6383   tree final_type = 0;
6384
6385   /* Nonzero if this is an operation like MIN or MAX which can
6386      safely be computed in short if both args are promoted shorts.
6387      Also implies COMMON.
6388      -1 indicates a bitwise operation; this makes a difference
6389      in the exact conditions for when it is safe to do the operation
6390      in a narrower mode.  */
6391   int shorten = 0;
6392
6393   /* Nonzero if this is a comparison operation;
6394      if both args are promoted shorts, compare the original shorts.
6395      Also implies COMMON.  */
6396   int short_compare = 0;
6397
6398   /* Nonzero if this is a right-shift operation, which can be computed on the
6399      original short and then promoted if the operand is a promoted short.  */
6400   int short_shift = 0;
6401
6402   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
6403   int common = 0;
6404
6405   if (convert_p)
6406     {
6407       op0 = default_conversion (orig_op0);
6408       op1 = default_conversion (orig_op1);
6409     }
6410   else
6411     {
6412       op0 = orig_op0;
6413       op1 = orig_op1;
6414     }
6415
6416   type0 = TREE_TYPE (op0);
6417   type1 = TREE_TYPE (op1);
6418
6419   /* The expression codes of the data types of the arguments tell us
6420      whether the arguments are integers, floating, pointers, etc.  */
6421   code0 = TREE_CODE (type0);
6422   code1 = TREE_CODE (type1);
6423
6424   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
6425   STRIP_TYPE_NOPS (op0);
6426   STRIP_TYPE_NOPS (op1);
6427
6428   /* If an error was already reported for one of the arguments,
6429      avoid reporting another error.  */
6430
6431   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6432     return error_mark_node;
6433
6434   switch (code)
6435     {
6436     case PLUS_EXPR:
6437       /* Handle the pointer + int case.  */
6438       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6439         return pointer_int_sum (PLUS_EXPR, op0, op1);
6440       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6441         return pointer_int_sum (PLUS_EXPR, op1, op0);
6442       else
6443         common = 1;
6444       break;
6445
6446     case MINUS_EXPR:
6447       /* Subtraction of two similar pointers.
6448          We must subtract them as integers, then divide by object size.  */
6449       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6450           && comp_target_types (type0, type1, 1))
6451         return pointer_diff (op0, op1);
6452       /* Handle pointer minus int.  Just like pointer plus int.  */
6453       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6454         return pointer_int_sum (MINUS_EXPR, op0, op1);
6455       else
6456         common = 1;
6457       break;
6458
6459     case MULT_EXPR:
6460       common = 1;
6461       break;
6462
6463     case TRUNC_DIV_EXPR:
6464     case CEIL_DIV_EXPR:
6465     case FLOOR_DIV_EXPR:
6466     case ROUND_DIV_EXPR:
6467     case EXACT_DIV_EXPR:
6468       /* Floating point division by zero is a legitimate way to obtain
6469          infinities and NaNs.  */
6470       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6471         warning ("division by zero");
6472
6473       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6474            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6475           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6476               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6477         {
6478           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6479             resultcode = RDIV_EXPR;
6480           else
6481             /* Although it would be tempting to shorten always here, that
6482                loses on some targets, since the modulo instruction is
6483                undefined if the quotient can't be represented in the
6484                computation mode.  We shorten only if unsigned or if
6485                dividing by something we know != -1.  */
6486             shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6487                        || (TREE_CODE (op1) == INTEGER_CST
6488                            && ! integer_all_onesp (op1)));
6489           common = 1;
6490         }
6491       break;
6492
6493     case BIT_AND_EXPR:
6494     case BIT_IOR_EXPR:
6495     case BIT_XOR_EXPR:
6496       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6497         shorten = -1;
6498       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
6499         common = 1;
6500       break;
6501
6502     case TRUNC_MOD_EXPR:
6503     case FLOOR_MOD_EXPR:
6504       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6505         warning ("division by zero");
6506
6507       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6508         {
6509           /* Although it would be tempting to shorten always here, that loses
6510              on some targets, since the modulo instruction is undefined if the
6511              quotient can't be represented in the computation mode.  We shorten
6512              only if unsigned or if dividing by something we know != -1.  */
6513           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6514                      || (TREE_CODE (op1) == INTEGER_CST
6515                          && ! integer_all_onesp (op1)));
6516           common = 1;
6517         }
6518       break;
6519
6520     case TRUTH_ANDIF_EXPR:
6521     case TRUTH_ORIF_EXPR:
6522     case TRUTH_AND_EXPR:
6523     case TRUTH_OR_EXPR:
6524     case TRUTH_XOR_EXPR:
6525       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
6526            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
6527           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
6528               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
6529         {
6530           /* Result of these operations is always an int,
6531              but that does not mean the operands should be
6532              converted to ints!  */
6533           result_type = integer_type_node;
6534           op0 = c_common_truthvalue_conversion (op0);
6535           op1 = c_common_truthvalue_conversion (op1);
6536           converted = 1;
6537         }
6538       break;
6539
6540       /* Shift operations: result has same type as first operand;
6541          always convert second operand to int.
6542          Also set SHORT_SHIFT if shifting rightward.  */
6543
6544     case RSHIFT_EXPR:
6545       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6546         {
6547           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6548             {
6549               if (tree_int_cst_sgn (op1) < 0)
6550                 warning ("right shift count is negative");
6551               else
6552                 {
6553                   if (! integer_zerop (op1))
6554                     short_shift = 1;
6555
6556                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6557                     warning ("right shift count >= width of type");
6558                 }
6559             }
6560
6561           /* Use the type of the value to be shifted.  */
6562           result_type = type0;
6563           /* Convert the shift-count to an integer, regardless of size
6564              of value being shifted.  */
6565           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6566             op1 = convert (integer_type_node, op1);
6567           /* Avoid converting op1 to result_type later.  */
6568           converted = 1;
6569         }
6570       break;
6571
6572     case LSHIFT_EXPR:
6573       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6574         {
6575           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6576             {
6577               if (tree_int_cst_sgn (op1) < 0)
6578                 warning ("left shift count is negative");
6579
6580               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6581                 warning ("left shift count >= width of type");
6582             }
6583
6584           /* Use the type of the value to be shifted.  */
6585           result_type = type0;
6586           /* Convert the shift-count to an integer, regardless of size
6587              of value being shifted.  */
6588           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6589             op1 = convert (integer_type_node, op1);
6590           /* Avoid converting op1 to result_type later.  */
6591           converted = 1;
6592         }
6593       break;
6594
6595     case RROTATE_EXPR:
6596     case LROTATE_EXPR:
6597       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6598         {
6599           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6600             {
6601               if (tree_int_cst_sgn (op1) < 0)
6602                 warning ("shift count is negative");
6603               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6604                 warning ("shift count >= width of type");
6605             }
6606
6607           /* Use the type of the value to be shifted.  */
6608           result_type = type0;
6609           /* Convert the shift-count to an integer, regardless of size
6610              of value being shifted.  */
6611           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6612             op1 = convert (integer_type_node, op1);
6613           /* Avoid converting op1 to result_type later.  */
6614           converted = 1;
6615         }
6616       break;
6617
6618     case EQ_EXPR:
6619     case NE_EXPR:
6620       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
6621         warning ("comparing floating point with == or != is unsafe");
6622       /* Result of comparison is always int,
6623          but don't convert the args to int!  */
6624       build_type = integer_type_node;
6625       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6626            || code0 == COMPLEX_TYPE
6627            || code0 == VECTOR_TYPE)
6628           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6629               || code1 == COMPLEX_TYPE
6630               || code1 == VECTOR_TYPE))
6631         short_compare = 1;
6632       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6633         {
6634           tree tt0 = TREE_TYPE (type0);
6635           tree tt1 = TREE_TYPE (type1);
6636           /* Anything compares with void *.  void * compares with anything.
6637              Otherwise, the targets must be compatible
6638              and both must be object or both incomplete.  */
6639           if (comp_target_types (type0, type1, 1))
6640             result_type = common_type (type0, type1);
6641           else if (VOID_TYPE_P (tt0))
6642             {
6643               /* op0 != orig_op0 detects the case of something
6644                  whose value is 0 but which isn't a valid null ptr const.  */
6645               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
6646                   && TREE_CODE (tt1) == FUNCTION_TYPE)
6647                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6648             }
6649           else if (VOID_TYPE_P (tt1))
6650             {
6651               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
6652                   && TREE_CODE (tt0) == FUNCTION_TYPE)
6653                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6654             }
6655           else
6656             pedwarn ("comparison of distinct pointer types lacks a cast");
6657
6658           if (result_type == NULL_TREE)
6659             result_type = ptr_type_node;
6660         }
6661       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6662                && integer_zerop (op1))
6663         result_type = type0;
6664       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6665                && integer_zerop (op0))
6666         result_type = type1;
6667       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6668         {
6669           result_type = type0;
6670           pedwarn ("comparison between pointer and integer");
6671         }
6672       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6673         {
6674           result_type = type1;
6675           pedwarn ("comparison between pointer and integer");
6676         }
6677       break;
6678
6679     case MAX_EXPR:
6680     case MIN_EXPR:
6681       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6682           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6683         shorten = 1;
6684       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6685         {
6686           if (comp_target_types (type0, type1, 1))
6687             {
6688               result_type = common_type (type0, type1);
6689               if (pedantic
6690                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6691                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6692             }
6693           else
6694             {
6695               result_type = ptr_type_node;
6696               pedwarn ("comparison of distinct pointer types lacks a cast");
6697             }
6698         }
6699       break;
6700
6701     case LE_EXPR:
6702     case GE_EXPR:
6703     case LT_EXPR:
6704     case GT_EXPR:
6705       build_type = integer_type_node;
6706       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6707           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6708         short_compare = 1;
6709       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6710         {
6711           if (comp_target_types (type0, type1, 1))
6712             {
6713               result_type = common_type (type0, type1);
6714               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
6715                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
6716                 pedwarn ("comparison of complete and incomplete pointers");
6717               else if (pedantic
6718                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6719                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6720             }
6721           else
6722             {
6723               result_type = ptr_type_node;
6724               pedwarn ("comparison of distinct pointer types lacks a cast");
6725             }
6726         }
6727       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6728                && integer_zerop (op1))
6729         {
6730           result_type = type0;
6731           if (pedantic || extra_warnings)
6732             pedwarn ("ordered comparison of pointer with integer zero");
6733         }
6734       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6735                && integer_zerop (op0))
6736         {
6737           result_type = type1;
6738           if (pedantic)
6739             pedwarn ("ordered comparison of pointer with integer zero");
6740         }
6741       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6742         {
6743           result_type = type0;
6744           pedwarn ("comparison between pointer and integer");
6745         }
6746       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6747         {
6748           result_type = type1;
6749           pedwarn ("comparison between pointer and integer");
6750         }
6751       break;
6752
6753     case UNORDERED_EXPR:
6754     case ORDERED_EXPR:
6755     case UNLT_EXPR:
6756     case UNLE_EXPR:
6757     case UNGT_EXPR:
6758     case UNGE_EXPR:
6759     case UNEQ_EXPR:
6760       build_type = integer_type_node;
6761       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
6762         {
6763           error ("unordered comparison on non-floating point argument");
6764           return error_mark_node;
6765         }
6766       common = 1;
6767       break;
6768
6769     default:
6770       break;
6771     }
6772
6773   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
6774        || code0 == VECTOR_TYPE)
6775       &&
6776       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
6777        || code1 == VECTOR_TYPE))
6778     {
6779       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
6780
6781       if (shorten || common || short_compare)
6782         result_type = common_type (type0, type1);
6783
6784       /* For certain operations (which identify themselves by shorten != 0)
6785          if both args were extended from the same smaller type,
6786          do the arithmetic in that type and then extend.
6787
6788          shorten !=0 and !=1 indicates a bitwise operation.
6789          For them, this optimization is safe only if
6790          both args are zero-extended or both are sign-extended.
6791          Otherwise, we might change the result.
6792          Eg, (short)-1 | (unsigned short)-1 is (int)-1
6793          but calculated in (unsigned short) it would be (unsigned short)-1.  */
6794
6795       if (shorten && none_complex)
6796         {
6797           int unsigned0, unsigned1;
6798           tree arg0 = get_narrower (op0, &unsigned0);
6799           tree arg1 = get_narrower (op1, &unsigned1);
6800           /* UNS is 1 if the operation to be done is an unsigned one.  */
6801           int uns = TREE_UNSIGNED (result_type);
6802           tree type;
6803
6804           final_type = result_type;
6805
6806           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
6807              but it *requires* conversion to FINAL_TYPE.  */
6808
6809           if ((TYPE_PRECISION (TREE_TYPE (op0))
6810                == TYPE_PRECISION (TREE_TYPE (arg0)))
6811               && TREE_TYPE (op0) != final_type)
6812             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
6813           if ((TYPE_PRECISION (TREE_TYPE (op1))
6814                == TYPE_PRECISION (TREE_TYPE (arg1)))
6815               && TREE_TYPE (op1) != final_type)
6816             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
6817
6818           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
6819
6820           /* For bitwise operations, signedness of nominal type
6821              does not matter.  Consider only how operands were extended.  */
6822           if (shorten == -1)
6823             uns = unsigned0;
6824
6825           /* Note that in all three cases below we refrain from optimizing
6826              an unsigned operation on sign-extended args.
6827              That would not be valid.  */
6828
6829           /* Both args variable: if both extended in same way
6830              from same width, do it in that width.
6831              Do it unsigned if args were zero-extended.  */
6832           if ((TYPE_PRECISION (TREE_TYPE (arg0))
6833                < TYPE_PRECISION (result_type))
6834               && (TYPE_PRECISION (TREE_TYPE (arg1))
6835                   == TYPE_PRECISION (TREE_TYPE (arg0)))
6836               && unsigned0 == unsigned1
6837               && (unsigned0 || !uns))
6838             result_type
6839               = c_common_signed_or_unsigned_type
6840               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
6841           else if (TREE_CODE (arg0) == INTEGER_CST
6842                    && (unsigned1 || !uns)
6843                    && (TYPE_PRECISION (TREE_TYPE (arg1))
6844                        < TYPE_PRECISION (result_type))
6845                    && (type
6846                        = c_common_signed_or_unsigned_type (unsigned1,
6847                                                            TREE_TYPE (arg1)),
6848                        int_fits_type_p (arg0, type)))
6849             result_type = type;
6850           else if (TREE_CODE (arg1) == INTEGER_CST
6851                    && (unsigned0 || !uns)
6852                    && (TYPE_PRECISION (TREE_TYPE (arg0))
6853                        < TYPE_PRECISION (result_type))
6854                    && (type
6855                        = c_common_signed_or_unsigned_type (unsigned0,
6856                                                            TREE_TYPE (arg0)),
6857                        int_fits_type_p (arg1, type)))
6858             result_type = type;
6859         }
6860
6861       /* Shifts can be shortened if shifting right.  */
6862
6863       if (short_shift)
6864         {
6865           int unsigned_arg;
6866           tree arg0 = get_narrower (op0, &unsigned_arg);
6867
6868           final_type = result_type;
6869
6870           if (arg0 == op0 && final_type == TREE_TYPE (op0))
6871             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
6872
6873           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
6874               /* We can shorten only if the shift count is less than the
6875                  number of bits in the smaller type size.  */
6876               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
6877               /* We cannot drop an unsigned shift after sign-extension.  */
6878               && (!TREE_UNSIGNED (final_type) || unsigned_arg))
6879             {
6880               /* Do an unsigned shift if the operand was zero-extended.  */
6881               result_type
6882                 = c_common_signed_or_unsigned_type (unsigned_arg,
6883                                                     TREE_TYPE (arg0));
6884               /* Convert value-to-be-shifted to that type.  */
6885               if (TREE_TYPE (op0) != result_type)
6886                 op0 = convert (result_type, op0);
6887               converted = 1;
6888             }
6889         }
6890
6891       /* Comparison operations are shortened too but differently.
6892          They identify themselves by setting short_compare = 1.  */
6893
6894       if (short_compare)
6895         {
6896           /* Don't write &op0, etc., because that would prevent op0
6897              from being kept in a register.
6898              Instead, make copies of the our local variables and
6899              pass the copies by reference, then copy them back afterward.  */
6900           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
6901           enum tree_code xresultcode = resultcode;
6902           tree val
6903             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
6904
6905           if (val != 0)
6906             return val;
6907
6908           op0 = xop0, op1 = xop1;
6909           converted = 1;
6910           resultcode = xresultcode;
6911
6912           if (warn_sign_compare && skip_evaluation == 0)
6913             {
6914               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
6915               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
6916               int unsignedp0, unsignedp1;
6917               tree primop0 = get_narrower (op0, &unsignedp0);
6918               tree primop1 = get_narrower (op1, &unsignedp1);
6919
6920               xop0 = orig_op0;
6921               xop1 = orig_op1;
6922               STRIP_TYPE_NOPS (xop0);
6923               STRIP_TYPE_NOPS (xop1);
6924
6925               /* Give warnings for comparisons between signed and unsigned
6926                  quantities that may fail.
6927
6928                  Do the checking based on the original operand trees, so that
6929                  casts will be considered, but default promotions won't be.
6930
6931                  Do not warn if the comparison is being done in a signed type,
6932                  since the signed type will only be chosen if it can represent
6933                  all the values of the unsigned type.  */
6934               if (! TREE_UNSIGNED (result_type))
6935                 /* OK */;
6936               /* Do not warn if both operands are the same signedness.  */
6937               else if (op0_signed == op1_signed)
6938                 /* OK */;
6939               else
6940                 {
6941                   tree sop, uop;
6942
6943                   if (op0_signed)
6944                     sop = xop0, uop = xop1;
6945                   else
6946                     sop = xop1, uop = xop0;
6947
6948                   /* Do not warn if the signed quantity is an
6949                      unsuffixed integer literal (or some static
6950                      constant expression involving such literals or a
6951                      conditional expression involving such literals)
6952                      and it is non-negative.  */
6953                   if (c_tree_expr_nonnegative_p (sop))
6954                     /* OK */;
6955                   /* Do not warn if the comparison is an equality operation,
6956                      the unsigned quantity is an integral constant, and it
6957                      would fit in the result if the result were signed.  */
6958                   else if (TREE_CODE (uop) == INTEGER_CST
6959                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
6960                            && int_fits_type_p
6961                            (uop, c_common_signed_type (result_type)))
6962                     /* OK */;
6963                   /* Do not warn if the unsigned quantity is an enumeration
6964                      constant and its maximum value would fit in the result
6965                      if the result were signed.  */
6966                   else if (TREE_CODE (uop) == INTEGER_CST
6967                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
6968                            && int_fits_type_p
6969                            (TYPE_MAX_VALUE (TREE_TYPE(uop)),
6970                             c_common_signed_type (result_type)))
6971                     /* OK */;
6972                   else
6973                     warning ("comparison between signed and unsigned");
6974                 }
6975
6976               /* Warn if two unsigned values are being compared in a size
6977                  larger than their original size, and one (and only one) is the
6978                  result of a `~' operator.  This comparison will always fail.
6979
6980                  Also warn if one operand is a constant, and the constant
6981                  does not have all bits set that are set in the ~ operand
6982                  when it is extended.  */
6983
6984               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
6985                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
6986                 {
6987                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
6988                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
6989                                             &unsignedp0);
6990                   else
6991                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
6992                                             &unsignedp1);
6993
6994                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
6995                     {
6996                       tree primop;
6997                       HOST_WIDE_INT constant, mask;
6998                       int unsignedp, bits;
6999
7000                       if (host_integerp (primop0, 0))
7001                         {
7002                           primop = primop1;
7003                           unsignedp = unsignedp1;
7004                           constant = tree_low_cst (primop0, 0);
7005                         }
7006                       else
7007                         {
7008                           primop = primop0;
7009                           unsignedp = unsignedp0;
7010                           constant = tree_low_cst (primop1, 0);
7011                         }
7012
7013                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7014                       if (bits < TYPE_PRECISION (result_type)
7015                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7016                         {
7017                           mask = (~ (HOST_WIDE_INT) 0) << bits;
7018                           if ((mask & constant) != mask)
7019                             warning ("comparison of promoted ~unsigned with constant");
7020                         }
7021                     }
7022                   else if (unsignedp0 && unsignedp1
7023                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7024                                < TYPE_PRECISION (result_type))
7025                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7026                                < TYPE_PRECISION (result_type)))
7027                     warning ("comparison of promoted ~unsigned with unsigned");
7028                 }
7029             }
7030         }
7031     }
7032
7033   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7034      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7035      Then the expression will be built.
7036      It will be given type FINAL_TYPE if that is nonzero;
7037      otherwise, it will be given type RESULT_TYPE.  */
7038
7039   if (!result_type)
7040     {
7041       binary_op_error (code);
7042       return error_mark_node;
7043     }
7044
7045   if (! converted)
7046     {
7047       if (TREE_TYPE (op0) != result_type)
7048         op0 = convert (result_type, op0);
7049       if (TREE_TYPE (op1) != result_type)
7050         op1 = convert (result_type, op1);
7051     }
7052
7053   if (build_type == NULL_TREE)
7054     build_type = result_type;
7055
7056   {
7057     tree result = build (resultcode, build_type, op0, op1);
7058     tree folded;
7059
7060     /* Treat expressions in initializers specially as they can't trap.  */
7061     folded = initializer_stack ? fold_initializer (result)
7062                                : fold (result);
7063     if (folded == result)
7064       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
7065     if (final_type != 0)
7066       return convert (final_type, folded);
7067     return folded;
7068   }
7069 }
7070