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