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