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