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