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         val = 1;
 512
 513         /* Target types must match incl. qualifiers.  */
 514         if (TREE_TYPE (t1) != TREE_TYPE (t2)
 515             && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
 516           return 0;
 517
 518         /* Sizes must match unless one is missing or variable.  */
 519         if (d1 == 0 || d2 == 0 || d1 == d2
 520             || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 521             || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 522             || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
 523             || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
 524           break;
 525
 526         if (! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
 527             || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
 528           val = 0;
 529
 530         break;
 531       }
 532
 533     case RECORD_TYPE:
 534       if (maybe_objc_comptypes (t1, t2, 0) == 1)
 535         val = 1;
 536       break;
 537
 538     default:
 539       break;
 540     }
 541   return attrval == 2 && val == 1 ? 2 : val;
 542 }
 543
 544 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
 545    ignoring their qualifiers.  */
 546
 547 static int
 548 comp_target_types (ttl, ttr)
 549      tree ttl, ttr;
 550 {
 551   int val;
 552
 553   /* Give maybe_objc_comptypes a crack at letting these types through.  */
 554   if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
 555     return val;
 556
 557   val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
 558                    TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
 559
 560   if (val == 2 && pedantic)
 561     pedwarn ("types are not quite compatible");
 562   return val;
 563 }
 564 \f
 565 /* Subroutines of `comptypes'.  */
 566
 567 /* Return 1 if two function types F1 and F2 are compatible.
 568    If either type specifies no argument types,
 569    the other must specify a fixed number of self-promoting arg types.
 570    Otherwise, if one type specifies only the number of arguments,
 571    the other must specify that number of self-promoting arg types.
 572    Otherwise, the argument types must match.  */
 573
 574 static int
 575 function_types_compatible_p (f1, f2)
 576      tree f1, f2;
 577 {
 578   tree args1, args2;
 579   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 580   int val = 1;
 581   int val1;
 582
 583   if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
 584         || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
 585     return 0;
 586
 587   args1 = TYPE_ARG_TYPES (f1);
 588   args2 = TYPE_ARG_TYPES (f2);
 589
 590   /* An unspecified parmlist matches any specified parmlist
 591      whose argument types don't need default promotions.  */
 592
 593   if (args1 == 0)
 594     {
 595       if (!self_promoting_args_p (args2))
 596         return 0;
 597       /* If one of these types comes from a non-prototype fn definition,
 598          compare that with the other type's arglist.
 599          If they don't match, ask for a warning (but no error).  */
 600       if (TYPE_ACTUAL_ARG_TYPES (f1)
 601           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
 602         val = 2;
 603       return val;
 604     }
 605   if (args2 == 0)
 606     {
 607       if (!self_promoting_args_p (args1))
 608         return 0;
 609       if (TYPE_ACTUAL_ARG_TYPES (f2)
 610           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
 611         val = 2;
 612       return val;
 613     }
 614
 615   /* Both types have argument lists: compare them and propagate results.  */
 616   val1 = type_lists_compatible_p (args1, args2);
 617   return val1 != 1 ? val1 : val;
 618 }
 619
 620 /* Check two lists of types for compatibility,
 621    returning 0 for incompatible, 1 for compatible,
 622    or 2 for compatible with warning.  */
 623
 624 static int
 625 type_lists_compatible_p (args1, args2)
 626      tree args1, args2;
 627 {
 628   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 629   int val = 1;
 630   int newval = 0;
 631
 632   while (1)
 633     {
 634       if (args1 == 0 && args2 == 0)
 635         return val;
 636       /* If one list is shorter than the other,
 637          they fail to match.  */
 638       if (args1 == 0 || args2 == 0)
 639         return 0;
 640       /* A null pointer instead of a type
 641          means there is supposed to be an argument
 642          but nothing is specified about what type it has.
 643          So match anything that self-promotes.  */
 644       if (TREE_VALUE (args1) == 0)
 645         {
 646           if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE)
 647             return 0;
 648         }
 649       else if (TREE_VALUE (args2) == 0)
 650         {
 651           if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE)
 652             return 0;
 653         }
 654       else if (! (newval = comptypes (TREE_VALUE (args1), TREE_VALUE (args2))))
 655         {
 656           /* Allow  wait (union {union wait *u; int *i} *)
 657              and  wait (union wait *)  to be compatible.  */
 658           if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
 659               && (TYPE_NAME (TREE_VALUE (args1)) == 0
 660                   || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
 661               && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
 662               && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
 663                                      TYPE_SIZE (TREE_VALUE (args2))))
 664             {
 665               tree memb;
 666               for (memb = TYPE_FIELDS (TREE_VALUE (args1));
 667                    memb; memb = TREE_CHAIN (memb))
 668                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
 669                   break;
 670               if (memb == 0)
 671                 return 0;
 672             }
 673           else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
 674                    && (TYPE_NAME (TREE_VALUE (args2)) == 0
 675                        || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
 676                    && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
 677                    && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
 678                                           TYPE_SIZE (TREE_VALUE (args1))))
 679             {
 680               tree memb;
 681               for (memb = TYPE_FIELDS (TREE_VALUE (args2));
 682                    memb; memb = TREE_CHAIN (memb))
 683                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
 684                   break;
 685               if (memb == 0)
 686                 return 0;
 687             }
 688           else
 689             return 0;
 690         }
 691
 692       /* comptypes said ok, but record if it said to warn.  */
 693       if (newval > val)
 694         val = newval;
 695
 696       args1 = TREE_CHAIN (args1);
 697       args2 = TREE_CHAIN (args2);
 698     }
 699 }
 700 \f
 701 /* Compute the value of the `sizeof' operator.  */
 702
 703 tree
 704 c_sizeof (type)
 705      tree type;
 706 {
 707   enum tree_code code = TREE_CODE (type);
 708   tree size;
 709
 710   if (code == FUNCTION_TYPE)
 711     {
 712       if (pedantic || warn_pointer_arith)
 713         pedwarn ("sizeof applied to a function type");
 714       size = size_one_node;
 715     }
 716   else if (code == VOID_TYPE)
 717     {
 718       if (pedantic || warn_pointer_arith)
 719         pedwarn ("sizeof applied to a void type");
 720       size = size_one_node;
 721     }
 722   else if (code == ERROR_MARK)
 723     size = size_one_node;
 724   else if (!COMPLETE_TYPE_P (type))
 725     {
 726       error ("sizeof applied to an incomplete type");
 727       size = size_zero_node;
 728     }
 729   else
 730     /* Convert in case a char is more than one unit.  */
 731     size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
 732                        size_int (TYPE_PRECISION (char_type_node)
 733                                  / BITS_PER_UNIT));
 734
 735   /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
 736      TYPE_IS_SIZETYPE means that certain things (like overflow) will
 737      never happen.  However, this node should really have type
 738      `size_t', which is just a typedef for an ordinary integer type.  */
 739   return fold (build1 (NOP_EXPR, c_size_type_node, size));
 740 }
 741
 742 tree
 743 c_sizeof_nowarn (type)
 744      tree type;
 745 {
 746   enum tree_code code = TREE_CODE (type);
 747   tree size;
 748
 749   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
 750     size = size_one_node;
 751   else if (!COMPLETE_TYPE_P (type))
 752     size = size_zero_node;
 753   else
 754     /* Convert in case a char is more than one unit.  */
 755     size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
 756                        size_int (TYPE_PRECISION (char_type_node)
 757                                  / BITS_PER_UNIT));
 758
 759   /* SIZE will have an integer type with TYPE_IS_SIZETYPE set.
 760      TYPE_IS_SIZETYPE means that certain things (like overflow) will
 761      never happen.  However, this node should really have type
 762      `size_t', which is just a typedef for an ordinary integer type.  */
 763   return fold (build1 (NOP_EXPR, c_size_type_node, size));
 764 }
 765
 766 /* Compute the size to increment a pointer by.  */
 767
 768 tree
 769 c_size_in_bytes (type)
 770      tree type;
 771 {
 772   enum tree_code code = TREE_CODE (type);
 773
 774   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
 775     return size_one_node;
 776
 777   if (!COMPLETE_OR_VOID_TYPE_P (type))
 778     {
 779       error ("arithmetic on pointer to an incomplete type");
 780       return size_one_node;
 781     }
 782
 783   /* Convert in case a char is more than one unit.  */
 784   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
 785                      size_int (TYPE_PRECISION (char_type_node)
 786                                / BITS_PER_UNIT));
 787 }
 788
 789 /* Implement the __alignof keyword: Return the minimum required
 790    alignment of TYPE, measured in bytes.  */
 791
 792 tree
 793 c_alignof (type)
 794      tree type;
 795 {
 796   enum tree_code code = TREE_CODE (type);
 797   tree t;
 798
 799   if (code == FUNCTION_TYPE)
 800     t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
 801   else if (code == VOID_TYPE || code == ERROR_MARK)
 802     t = size_one_node;
 803   else if (code == ERROR_MARK)
 804     t = size_one_node;
 805   else if (!COMPLETE_TYPE_P (type))
 806     {
 807       error ("__alignof__ applied to an incomplete type");
 808       t = size_zero_node;
 809     }
 810   else
 811     t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
 812
 813   return fold (build1 (NOP_EXPR, c_size_type_node, t));
 814 }
 815 \f
 816 /* Implement the __alignof keyword: Return the minimum required
 817    alignment of EXPR, measured in bytes.  For VAR_DECL's and
 818    FIELD_DECL's return DECL_ALIGN (which can be set from an
 819    "aligned" __attribute__ specification).  */
 820
 821 tree
 822 c_alignof_expr (expr)
 823      tree expr;
 824 {
 825   tree t;
 826
 827   if (TREE_CODE (expr) == VAR_DECL)
 828     t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
 829
 830   else if (TREE_CODE (expr) == COMPONENT_REF
 831            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
 832     {
 833       error ("`__alignof' applied to a bit-field");
 834       t = size_one_node;
 835     }
 836   else if (TREE_CODE (expr) == COMPONENT_REF
 837       && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
 838     t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
 839
 840   else if (TREE_CODE (expr) == INDIRECT_REF)
 841     {
 842       tree t = TREE_OPERAND (expr, 0);
 843       tree best = t;
 844       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
 845
 846       while (TREE_CODE (t) == NOP_EXPR
 847               && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
 848         {
 849           int thisalign;
 850
 851           t = TREE_OPERAND (t, 0);
 852           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
 853           if (thisalign > bestalign)
 854             best = t, bestalign = thisalign;
 855         }
 856       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
 857     }
 858   else
 859     return c_alignof (TREE_TYPE (expr));
 860
 861   return fold (build1 (NOP_EXPR, c_size_type_node, t));
 862 }
 863
 864 /* Return either DECL or its known constant value (if it has one).  */
 865
 866 tree
 867 decl_constant_value (decl)
 868      tree decl;
 869 {
 870   if (/* Don't change a variable array bound or initial value to a constant
 871          in a place where a variable is invalid.  */
 872       current_function_decl != 0
 873       && ! TREE_THIS_VOLATILE (decl)
 874       && TREE_READONLY (decl)
 875       && DECL_INITIAL (decl) != 0
 876       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 877       /* This is invalid if initial value is not constant.
 878          If it has either a function call, a memory reference,
 879          or a variable, then re-evaluating it could give different results.  */
 880       && TREE_CONSTANT (DECL_INITIAL (decl))
 881       /* Check for cases where this is sub-optimal, even though valid.  */
 882       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 883     return DECL_INITIAL (decl);
 884   return decl;
 885 }
 886
 887 /* Return either DECL or its known constant value (if it has one), but
 888    return DECL if pedantic or DECL has mode BLKmode.  This is for
 889    bug-compatibility with the old behavior of decl_constant_value
 890    (before GCC 3.0); every use of this function is a bug and it should
 891    be removed before GCC 3.1.  It is not appropriate to use pedantic
 892    in a way that affects optimization, and BLKmode is probably not the
 893    right test for avoiding misoptimizations either.  */
 894
 895 static tree
 896 decl_constant_value_for_broken_optimization (decl)
 897      tree decl;
 898 {
 899   if (pedantic || DECL_MODE (decl) == BLKmode)
 900     return decl;
 901   else
 902     return decl_constant_value (decl);
 903 }
 904
 905 /* Perform default promotions for C data used in expressions.
 906    Arrays and functions are converted to pointers;
 907    enumeral types or short or char, to int.
 908    In addition, manifest constants symbols are replaced by their values.  */
 909
 910 tree
 911 default_conversion (exp)
 912      tree exp;
 913 {
 914   register tree type = TREE_TYPE (exp);
 915   register enum tree_code code = TREE_CODE (type);
 916
 917   /* Constants can be used directly unless they're not loadable.  */
 918   if (TREE_CODE (exp) == CONST_DECL)
 919     exp = DECL_INITIAL (exp);
 920
 921   /* Replace a nonvolatile const static variable with its value unless
 922      it is an array, in which case we must be sure that taking the
 923      address of the array produces consistent results.  */
 924   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
 925     {
 926       exp = decl_constant_value_for_broken_optimization (exp);
 927       type = TREE_TYPE (exp);
 928     }
 929
 930   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
 931      an lvalue.
 932
 933      Do not use STRIP_NOPS here!  It will remove conversions from pointer
 934      to integer and cause infinite recursion.  */
 935   while (TREE_CODE (exp) == NON_LVALUE_EXPR
 936          || (TREE_CODE (exp) == NOP_EXPR
 937              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
 938     exp = TREE_OPERAND (exp, 0);
 939
 940   /* Normally convert enums to int,
 941      but convert wide enums to something wider.  */
 942   if (code == ENUMERAL_TYPE)
 943     {
 944       type = type_for_size (MAX (TYPE_PRECISION (type),
 945                                  TYPE_PRECISION (integer_type_node)),
 946                             ((flag_traditional
 947                               || (TYPE_PRECISION (type)
 948                                   >= TYPE_PRECISION (integer_type_node)))
 949                              && TREE_UNSIGNED (type)));
 950
 951       return convert (type, exp);
 952     }
 953
 954   if (TREE_CODE (exp) == COMPONENT_REF
 955       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
 956       /* If it's thinner than an int, promote it like a
 957          c_promoting_integer_type_p, otherwise leave it alone.  */
 958       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
 959                                TYPE_PRECISION (integer_type_node)))
 960     return convert (flag_traditional && TREE_UNSIGNED (type)
 961                     ? unsigned_type_node : integer_type_node,
 962                     exp);
 963
 964   if (c_promoting_integer_type_p (type))
 965     {
 966       /* Traditionally, unsignedness is preserved in default promotions.
 967          Also preserve unsignedness if not really getting any wider.  */
 968       if (TREE_UNSIGNED (type)
 969           && (flag_traditional
 970               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
 971         return convert (unsigned_type_node, exp);
 972
 973       return convert (integer_type_node, exp);
 974     }
 975
 976   if (flag_traditional && !flag_allow_single_precision
 977       && TYPE_MAIN_VARIANT (type) == float_type_node)
 978     return convert (double_type_node, exp);
 979
 980   if (code == VOID_TYPE)
 981     {
 982       error ("void value not ignored as it ought to be");
 983       return error_mark_node;
 984     }
 985   if (code == FUNCTION_TYPE)
 986     {
 987       return build_unary_op (ADDR_EXPR, exp, 0);
 988     }
 989   if (code == ARRAY_TYPE)
 990     {
 991       register tree adr;
 992       tree restype = TREE_TYPE (type);
 993       tree ptrtype;
 994       int constp = 0;
 995       int volatilep = 0;
 996
 997       if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
 998         {
 999           constp = TREE_READONLY (exp);
1000           volatilep = TREE_THIS_VOLATILE (exp);
1001         }
1002
1003       if (TYPE_QUALS (type) || constp || volatilep)
1004         restype
1005           = c_build_qualified_type (restype,
1006                                     TYPE_QUALS (type)
1007                                     | (constp * TYPE_QUAL_CONST)
1008                                     | (volatilep * TYPE_QUAL_VOLATILE));
1009
1010       if (TREE_CODE (exp) == INDIRECT_REF)
1011         return convert (TYPE_POINTER_TO (restype),
1012                         TREE_OPERAND (exp, 0));
1013
1014       if (TREE_CODE (exp) == COMPOUND_EXPR)
1015         {
1016           tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1017           return build (COMPOUND_EXPR, TREE_TYPE (op1),
1018                         TREE_OPERAND (exp, 0), op1);
1019         }
1020
1021       if (! lvalue_p (exp)
1022           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1023         {
1024           error ("invalid use of non-lvalue array");
1025           return error_mark_node;
1026         }
1027
1028       ptrtype = build_pointer_type (restype);
1029
1030       if (TREE_CODE (exp) == VAR_DECL)
1031         {
1032           /* ??? This is not really quite correct
1033              in that the type of the operand of ADDR_EXPR
1034              is not the target type of the type of the ADDR_EXPR itself.
1035              Question is, can this lossage be avoided?  */
1036           adr = build1 (ADDR_EXPR, ptrtype, exp);
1037           if (mark_addressable (exp) == 0)
1038             return error_mark_node;
1039           TREE_CONSTANT (adr) = staticp (exp);
1040           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1041           return adr;
1042         }
1043       /* This way is better for a COMPONENT_REF since it can
1044          simplify the offset for a component.  */
1045       adr = build_unary_op (ADDR_EXPR, exp, 1);
1046       return convert (ptrtype, adr);
1047     }
1048   return exp;
1049 }
1050 \f
1051 /* Look up component name in the structure type definition.
1052
1053    If this component name is found indirectly within an anonymous union,
1054    store in *INDIRECT the component which directly contains
1055    that anonymous union.  Otherwise, set *INDIRECT to 0.  */
1056
1057 static tree
1058 lookup_field (type, component, indirect)
1059      tree type, component;
1060      tree *indirect;
1061 {
1062   tree field;
1063
1064   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1065      to the field elements.  Use a binary search on this array to quickly
1066      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1067      will always be set for structures which have many elements.  */
1068
1069   if (TYPE_LANG_SPECIFIC (type))
1070     {
1071       int bot, top, half;
1072       tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1073
1074       field = TYPE_FIELDS (type);
1075       bot = 0;
1076       top = TYPE_LANG_SPECIFIC (type)->len;
1077       while (top - bot > 1)
1078         {
1079           half = (top - bot + 1) >> 1;
1080           field = field_array[bot+half];
1081
1082           if (DECL_NAME (field) == NULL_TREE)
1083             {
1084               /* Step through all anon unions in linear fashion.  */
1085               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1086                 {
1087                   tree anon = 0, junk;
1088
1089                   field = field_array[bot++];
1090                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1091                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1092                     anon = lookup_field (TREE_TYPE (field), component, &junk);
1093
1094                   if (anon != NULL_TREE)
1095                     {
1096                       *indirect = field;
1097                       return anon;
1098                     }
1099                 }
1100
1101               /* Entire record is only anon unions.  */
1102               if (bot > top)
1103                 return NULL_TREE;
1104
1105               /* Restart the binary search, with new lower bound.  */
1106               continue;
1107             }
1108
1109           if (DECL_NAME (field) == component)
1110             break;
1111           if (DECL_NAME (field) < component)
1112             bot += half;
1113           else
1114             top = bot + half;
1115         }
1116
1117       if (DECL_NAME (field_array[bot]) == component)
1118         field = field_array[bot];
1119       else if (DECL_NAME (field) != component)
1120         field = 0;
1121     }
1122   else
1123     {
1124       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1125         {
1126           if (DECL_NAME (field) == NULL_TREE)
1127             {
1128               tree junk;
1129               tree anon = 0;
1130
1131               if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1132                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1133                 anon = lookup_field (TREE_TYPE (field), component, &junk);
1134
1135               if (anon != NULL_TREE)
1136                 {
1137                   *indirect = field;
1138                   return anon;
1139                 }
1140             }
1141
1142           if (DECL_NAME (field) == component)
1143             break;
1144         }
1145     }
1146
1147   *indirect = NULL_TREE;
1148   return field;
1149 }
1150
1151 /* Make an expression to refer to the COMPONENT field of
1152    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1153
1154 tree
1155 build_component_ref (datum, component)
1156      tree datum, component;
1157 {
1158   register tree type = TREE_TYPE (datum);
1159   register enum tree_code code = TREE_CODE (type);
1160   register tree field = NULL;
1161   register tree ref;
1162
1163   /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1164      unless we are not to support things not strictly ANSI.  */
1165   switch (TREE_CODE (datum))
1166     {
1167     case COMPOUND_EXPR:
1168       {
1169         tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1170         return build (COMPOUND_EXPR, TREE_TYPE (value),
1171                       TREE_OPERAND (datum, 0), value);
1172       }
1173     case COND_EXPR:
1174       return build_conditional_expr
1175         (TREE_OPERAND (datum, 0),
1176          build_component_ref (TREE_OPERAND (datum, 1), component),
1177          build_component_ref (TREE_OPERAND (datum, 2), component));
1178
1179     default:
1180       break;
1181     }
1182
1183   /* See if there is a field or component with name COMPONENT.  */
1184
1185   if (code == RECORD_TYPE || code == UNION_TYPE)
1186     {
1187       tree indirect = 0;
1188
1189       if (!COMPLETE_TYPE_P (type))
1190         {
1191           incomplete_type_error (NULL_TREE, type);
1192           return error_mark_node;
1193         }
1194
1195       field = lookup_field (type, component, &indirect);
1196
1197       if (!field)
1198         {
1199           error ("%s has no member named `%s'",
1200                  code == RECORD_TYPE ? "structure" : "union",
1201                  IDENTIFIER_POINTER (component));
1202           return error_mark_node;
1203         }
1204       if (TREE_TYPE (field) == error_mark_node)
1205         return error_mark_node;
1206
1207       /* If FIELD was found buried within an anonymous union,
1208          make one COMPONENT_REF to get that anonymous union,
1209          then fall thru to make a second COMPONENT_REF to get FIELD.  */
1210       if (indirect != 0)
1211         {
1212           ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1213           if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1214             TREE_READONLY (ref) = 1;
1215           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1216             TREE_THIS_VOLATILE (ref) = 1;
1217           datum = ref;
1218         }
1219
1220       ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1221
1222       if (TREE_READONLY (datum) || TREE_READONLY (field))
1223         TREE_READONLY (ref) = 1;
1224       if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1225         TREE_THIS_VOLATILE (ref) = 1;
1226
1227       return ref;
1228     }
1229   else if (code != ERROR_MARK)
1230     error ("request for member `%s' in something not a structure or union",
1231             IDENTIFIER_POINTER (component));
1232
1233   return error_mark_node;
1234 }
1235 \f
1236 /* Given an expression PTR for a pointer, return an expression
1237    for the value pointed to.
1238    ERRORSTRING is the name of the operator to appear in error messages.  */
1239
1240 tree
1241 build_indirect_ref (ptr, errorstring)
1242      tree ptr;
1243      const char *errorstring;
1244 {
1245   register tree pointer = default_conversion (ptr);
1246   register tree type = TREE_TYPE (pointer);
1247
1248   if (TREE_CODE (type) == POINTER_TYPE)
1249     {
1250       if (TREE_CODE (pointer) == ADDR_EXPR
1251           && !flag_volatile
1252           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1253               == TREE_TYPE (type)))
1254         return TREE_OPERAND (pointer, 0);
1255       else
1256         {
1257           tree t = TREE_TYPE (type);
1258           register tree ref = build1 (INDIRECT_REF,
1259                                       TYPE_MAIN_VARIANT (t), pointer);
1260
1261           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1262             {
1263               error ("dereferencing pointer to incomplete type");
1264               return error_mark_node;
1265             }
1266           if (VOID_TYPE_P (t) && skip_evaluation == 0)
1267             warning ("dereferencing `void *' pointer");
1268
1269           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1270              so that we get the proper error message if the result is used
1271              to assign to.  Also, &* is supposed to be a no-op.
1272              And ANSI C seems to specify that the type of the result
1273              should be the const type.  */
1274           /* A de-reference of a pointer to const is not a const.  It is valid
1275              to change it via some other pointer.  */
1276           TREE_READONLY (ref) = TYPE_READONLY (t);
1277           TREE_SIDE_EFFECTS (ref)
1278             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1279           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1280           return ref;
1281         }
1282     }
1283   else if (TREE_CODE (pointer) != ERROR_MARK)
1284     error ("invalid type argument of `%s'", errorstring);
1285   return error_mark_node;
1286 }
1287
1288 /* This handles expressions of the form "a[i]", which denotes
1289    an array reference.
1290
1291    This is logically equivalent in C to *(a+i), but we may do it differently.
1292    If A is a variable or a member, we generate a primitive ARRAY_REF.
1293    This avoids forcing the array out of registers, and can work on
1294    arrays that are not lvalues (for example, members of structures returned
1295    by functions).  */
1296
1297 tree
1298 build_array_ref (array, index)
1299      tree array, index;
1300 {
1301   if (index == 0)
1302     {
1303       error ("subscript missing in array reference");
1304       return error_mark_node;
1305     }
1306
1307   if (TREE_TYPE (array) == error_mark_node
1308       || TREE_TYPE (index) == error_mark_node)
1309     return error_mark_node;
1310
1311   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1312       && TREE_CODE (array) != INDIRECT_REF)
1313     {
1314       tree rval, type;
1315
1316       /* Subscripting with type char is likely to lose
1317          on a machine where chars are signed.
1318          So warn on any machine, but optionally.
1319          Don't warn for unsigned char since that type is safe.
1320          Don't warn for signed char because anyone who uses that
1321          must have done so deliberately.  */
1322       if (warn_char_subscripts
1323           && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1324         warning ("array subscript has type `char'");
1325
1326       /* Apply default promotions *after* noticing character types.  */
1327       index = default_conversion (index);
1328
1329       /* Require integer *after* promotion, for sake of enums.  */
1330       if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1331         {
1332           error ("array subscript is not an integer");
1333           return error_mark_node;
1334         }
1335
1336       /* An array that is indexed by a non-constant
1337          cannot be stored in a register; we must be able to do
1338          address arithmetic on its address.
1339          Likewise an array of elements of variable size.  */
1340       if (TREE_CODE (index) != INTEGER_CST
1341           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1342               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1343         {
1344           if (mark_addressable (array) == 0)
1345             return error_mark_node;
1346         }
1347       /* An array that is indexed by a constant value which is not within
1348          the array bounds cannot be stored in a register either; because we
1349          would get a crash in store_bit_field/extract_bit_field when trying
1350          to access a non-existent part of the register.  */
1351       if (TREE_CODE (index) == INTEGER_CST
1352           && TYPE_VALUES (TREE_TYPE (array))
1353           && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1354         {
1355           if (mark_addressable (array) == 0)
1356             return error_mark_node;
1357         }
1358
1359       if (pedantic)
1360         {
1361           tree foo = array;
1362           while (TREE_CODE (foo) == COMPONENT_REF)
1363             foo = TREE_OPERAND (foo, 0);
1364           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1365             pedwarn ("ISO C forbids subscripting `register' array");
1366           else if (! flag_isoc99 && ! lvalue_p (foo))
1367             pedwarn ("ISO C89 forbids subscripting non-lvalue array");
1368         }
1369
1370       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1371       rval = build (ARRAY_REF, type, array, index);
1372       /* Array ref is const/volatile if the array elements are
1373          or if the array is.  */
1374       TREE_READONLY (rval)
1375         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1376             | TREE_READONLY (array));
1377       TREE_SIDE_EFFECTS (rval)
1378         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1379             | TREE_SIDE_EFFECTS (array));
1380       TREE_THIS_VOLATILE (rval)
1381         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1382             /* This was added by rms on 16 Nov 91.
1383                It fixes  vol struct foo *a;  a->elts[1]
1384                in an inline function.
1385                Hope it doesn't break something else.  */
1386             | TREE_THIS_VOLATILE (array));
1387       return require_complete_type (fold (rval));
1388     }
1389
1390   {
1391     tree ar = default_conversion (array);
1392     tree ind = default_conversion (index);
1393
1394     /* Do the same warning check as above, but only on the part that's
1395        syntactically the index and only if it is also semantically
1396        the index.  */
1397     if (warn_char_subscripts
1398         && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1399         && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1400       warning ("subscript has type `char'");
1401
1402     /* Put the integer in IND to simplify error checking.  */
1403     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1404       {
1405         tree temp = ar;
1406         ar = ind;
1407         ind = temp;
1408       }
1409
1410     if (ar == error_mark_node)
1411       return ar;
1412
1413     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1414         || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1415       {
1416         error ("subscripted value is neither array nor pointer");
1417         return error_mark_node;
1418       }
1419     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1420       {
1421         error ("array subscript is not an integer");
1422         return error_mark_node;
1423       }
1424
1425     return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1426                                "array indexing");
1427   }
1428 }
1429 \f
1430 /* Build an external reference to identifier ID.  FUN indicates
1431    whether this will be used for a function call.  */
1432 tree
1433 build_external_ref (id, fun)
1434      tree id;
1435      int fun;
1436 {
1437   tree ref;
1438   tree decl = lookup_name (id);
1439   tree objc_ivar = lookup_objc_ivar (id);
1440
1441   if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl))
1442     {
1443       if (objc_ivar)
1444         ref = objc_ivar;
1445       else if (fun)
1446         {
1447           if (!decl || decl == error_mark_node)
1448             /* Ordinary implicit function declaration.  */
1449             ref = implicitly_declare (id);
1450           else
1451             {
1452               /* Implicit declaration of built-in function.  Don't
1453                  change the built-in declaration, but don't let this
1454                  go by silently, either.  */
1455               implicit_decl_warning (id);
1456
1457               /* only issue this warning once */
1458               C_DECL_ANTICIPATED (decl) = 0;
1459               ref = decl;
1460             }
1461         }
1462       else
1463         {
1464           /* Reference to undeclared variable, including reference to
1465              builtin outside of function-call context.  */
1466           if (current_function_decl == 0)
1467             error ("`%s' undeclared here (not in a function)",
1468                    IDENTIFIER_POINTER (id));
1469           else
1470             {
1471               if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node
1472                   || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl)
1473                 {
1474                   error ("`%s' undeclared (first use in this function)",
1475                          IDENTIFIER_POINTER (id));
1476
1477                   if (! undeclared_variable_notice)
1478                     {
1479                       error ("(Each undeclared identifier is reported only once");
1480                       error ("for each function it appears in.)");
1481                       undeclared_variable_notice = 1;
1482                     }
1483                 }
1484               IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node;
1485               IDENTIFIER_ERROR_LOCUS (id) = current_function_decl;
1486             }
1487           return error_mark_node;
1488         }
1489     }
1490   else
1491     {
1492       /* Properly declared variable or function reference.  */
1493       if (!objc_ivar)
1494         ref = decl;
1495       else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id))
1496         {
1497           warning ("local declaration of `%s' hides instance variable",
1498                    IDENTIFIER_POINTER (id));
1499           ref = decl;
1500         }
1501       else
1502         ref = objc_ivar;
1503     }
1504
1505   if (TREE_TYPE (ref) == error_mark_node)
1506     return error_mark_node;
1507
1508   assemble_external (ref);
1509   TREE_USED (ref) = 1;
1510
1511   if (TREE_CODE (ref) == CONST_DECL)
1512     {
1513       ref = DECL_INITIAL (ref);
1514       TREE_CONSTANT (ref) = 1;
1515     }
1516
1517   return ref;
1518 }
1519
1520 /* Build a function call to function FUNCTION with parameters PARAMS.
1521    PARAMS is a list--a chain of TREE_LIST nodes--in which the
1522    TREE_VALUE of each node is a parameter-expression.
1523    FUNCTION's data type may be a function type or a pointer-to-function.  */
1524
1525 tree
1526 build_function_call (function, params)
1527      tree function, params;
1528 {
1529   register tree fntype, fundecl = 0;
1530   register tree coerced_params;
1531   tree name = NULL_TREE, assembler_name = NULL_TREE, result;
1532
1533   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1534   STRIP_TYPE_NOPS (function);
1535
1536   /* Convert anything with function type to a pointer-to-function.  */
1537   if (TREE_CODE (function) == FUNCTION_DECL)
1538     {
1539       name = DECL_NAME (function);
1540       assembler_name = DECL_ASSEMBLER_NAME (function);
1541
1542       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1543          (because calling an inline function does not mean the function
1544          needs to be separately compiled).  */
1545       fntype = build_type_variant (TREE_TYPE (function),
1546                                    TREE_READONLY (function),
1547                                    TREE_THIS_VOLATILE (function));
1548       fundecl = function;
1549       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1550     }
1551   else
1552     function = default_conversion (function);
1553
1554   fntype = TREE_TYPE (function);
1555
1556   if (TREE_CODE (fntype) == ERROR_MARK)
1557     return error_mark_node;
1558
1559   if (!(TREE_CODE (fntype) == POINTER_TYPE
1560         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1561     {
1562       error ("called object is not a function");
1563       return error_mark_node;
1564     }
1565
1566   /* fntype now gets the type of function pointed to.  */
1567   fntype = TREE_TYPE (fntype);
1568
1569   /* Convert the parameters to the types declared in the
1570      function prototype, or apply default promotions.  */
1571
1572   coerced_params
1573     = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1574
1575   /* Check for errors in format strings.  */
1576
1577   if (warn_format && (name || assembler_name))
1578     check_function_format (NULL, name, assembler_name, coerced_params);
1579
1580   /* Recognize certain built-in functions so we can make tree-codes
1581      other than CALL_EXPR.  We do this when it enables fold-const.c
1582      to do something useful.  */
1583
1584   if (TREE_CODE (function) == ADDR_EXPR
1585       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1586       && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1587     {
1588       result = expand_tree_builtin (TREE_OPERAND (function, 0),
1589                                     params, coerced_params);
1590       if (result)
1591         return result;
1592     }
1593
1594   result = build (CALL_EXPR, TREE_TYPE (fntype),
1595                   function, coerced_params, NULL_TREE);
1596   TREE_SIDE_EFFECTS (result) = 1;
1597   result = fold (result);
1598
1599   if (VOID_TYPE_P (TREE_TYPE (result)))
1600     return result;
1601   return require_complete_type (result);
1602 }
1603 \f
1604 /* Convert the argument expressions in the list VALUES
1605    to the types in the list TYPELIST.  The result is a list of converted
1606    argument expressions.
1607
1608    If TYPELIST is exhausted, or when an element has NULL as its type,
1609    perform the default conversions.
1610
1611    PARMLIST is the chain of parm decls for the function being called.
1612    It may be 0, if that info is not available.
1613    It is used only for generating error messages.
1614
1615    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
1616
1617    This is also where warnings about wrong number of args are generated.
1618
1619    Both VALUES and the returned value are chains of TREE_LIST nodes
1620    with the elements of the list in the TREE_VALUE slots of those nodes.  */
1621
1622 static tree
1623 convert_arguments (typelist, values, name, fundecl)
1624      tree typelist, values, name, fundecl;
1625 {
1626   register tree typetail, valtail;
1627   register tree result = NULL;
1628   int parmnum;
1629
1630   /* Scan the given expressions and types, producing individual
1631      converted arguments and pushing them on RESULT in reverse order.  */
1632
1633   for (valtail = values, typetail = typelist, parmnum = 0;
1634        valtail;
1635        valtail = TREE_CHAIN (valtail), parmnum++)
1636     {
1637       register tree type = typetail ? TREE_VALUE (typetail) : 0;
1638       register tree val = TREE_VALUE (valtail);
1639
1640       if (type == void_type_node)
1641         {
1642           if (name)
1643             error ("too many arguments to function `%s'",
1644                    IDENTIFIER_POINTER (name));
1645           else
1646             error ("too many arguments to function");
1647           break;
1648         }
1649
1650       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1651       /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
1652          to convert automatically to a pointer.  */
1653       if (TREE_CODE (val) == NON_LVALUE_EXPR)
1654         val = TREE_OPERAND (val, 0);
1655
1656       if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1657           || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1658         val = default_conversion (val);
1659
1660       val = require_complete_type (val);
1661
1662       if (type != 0)
1663         {
1664           /* Formal parm type is specified by a function prototype.  */
1665           tree parmval;
1666
1667           if (!COMPLETE_TYPE_P (type))
1668             {
1669               error ("type of formal parameter %d is incomplete", parmnum + 1);
1670               parmval = val;
1671             }
1672           else
1673             {
1674               /* Optionally warn about conversions that
1675                  differ from the default conversions.  */
1676               if (warn_conversion || warn_traditional)
1677                 {
1678                   int formal_prec = TYPE_PRECISION (type);
1679
1680                   if (INTEGRAL_TYPE_P (type)
1681                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1682                     warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1683                   if (INTEGRAL_TYPE_P (type)
1684                       && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1685                     warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1686                   else if (TREE_CODE (type) == COMPLEX_TYPE
1687                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1688                     warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1689                   else if (TREE_CODE (type) == REAL_TYPE
1690                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1691                     warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1692                   else if (TREE_CODE (type) == COMPLEX_TYPE
1693                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1694                     warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1695                   else if (TREE_CODE (type) == REAL_TYPE
1696                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1697                     warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1698                   /* ??? At some point, messages should be written about
1699                      conversions between complex types, but that's too messy
1700                      to do now.  */
1701                   else if (TREE_CODE (type) == REAL_TYPE
1702                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1703                     {
1704                       /* Warn if any argument is passed as `float',
1705                          since without a prototype it would be `double'.  */
1706                       if (formal_prec == TYPE_PRECISION (float_type_node))
1707                         warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1708                     }
1709                   /* Detect integer changing in width or signedness.
1710                      These warnings are only activated with
1711                      -Wconversion, not with -Wtraditional.  */
1712                   else if (warn_conversion && INTEGRAL_TYPE_P (type)
1713                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1714                     {
1715                       tree would_have_been = default_conversion (val);
1716                       tree type1 = TREE_TYPE (would_have_been);
1717
1718                       if (TREE_CODE (type) == ENUMERAL_TYPE
1719                           && type == TREE_TYPE (val))
1720                         /* No warning if function asks for enum
1721                            and the actual arg is that enum type.  */
1722                         ;
1723                       else if (formal_prec != TYPE_PRECISION (type1))
1724                         warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1725                       else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1726                         ;
1727                       /* Don't complain if the formal parameter type
1728                          is an enum, because we can't tell now whether
1729                          the value was an enum--even the same enum.  */
1730                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
1731                         ;
1732                       else if (TREE_CODE (val) == INTEGER_CST
1733                                && int_fits_type_p (val, type))
1734                         /* Change in signedness doesn't matter
1735                            if a constant value is unaffected.  */
1736                         ;
1737                       /* Likewise for a constant in a NOP_EXPR.  */
1738                       else if (TREE_CODE (val) == NOP_EXPR
1739                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1740                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
1741                         ;
1742 #if 0 /* We never get such tree structure here.  */
1743                       else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1744                                && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1745                                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1746                         /* Change in signedness doesn't matter
1747                            if an enum value is unaffected.  */
1748                         ;
1749 #endif
1750                       /* If the value is extended from a narrower
1751                          unsigned type, it doesn't matter whether we
1752                          pass it as signed or unsigned; the value
1753                          certainly is the same either way.  */
1754                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1755                                && TREE_UNSIGNED (TREE_TYPE (val)))
1756                         ;
1757                       else if (TREE_UNSIGNED (type))
1758                         warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1759                       else
1760                         warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1761                     }
1762                 }
1763
1764               parmval = convert_for_assignment (type, val,
1765                                                 (char *) 0, /* arg passing  */
1766                                                 fundecl, name, parmnum + 1);
1767
1768               if (PROMOTE_PROTOTYPES
1769                   && INTEGRAL_TYPE_P (type)
1770                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1771                 parmval = default_conversion (parmval);
1772             }
1773           result = tree_cons (NULL_TREE, parmval, result);
1774         }
1775       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1776                && (TYPE_PRECISION (TREE_TYPE (val))
1777                    < TYPE_PRECISION (double_type_node)))
1778         /* Convert `float' to `double'.  */
1779         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1780       else
1781         /* Convert `short' and `char' to full-size `int'.  */
1782         result = tree_cons (NULL_TREE, default_conversion (val), result);
1783
1784       if (typetail)
1785         typetail = TREE_CHAIN (typetail);
1786     }
1787
1788   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1789     {
1790       if (name)
1791         error ("too few arguments to function `%s'",
1792                IDENTIFIER_POINTER (name));
1793       else
1794         error ("too few arguments to function");
1795     }
1796
1797   return nreverse (result);
1798 }
1799 \f
1800 /* This is the entry point used by the parser
1801    for binary operators in the input.
1802    In addition to constructing the expression,
1803    we check for operands that were written with other binary operators
1804    in a way that is likely to confuse the user.  */
1805
1806 tree
1807 parser_build_binary_op (code, arg1, arg2)
1808      enum tree_code code;
1809      tree arg1, arg2;
1810 {
1811   tree result = build_binary_op (code, arg1, arg2, 1);
1812
1813   char class;
1814   char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1815   char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1816   enum tree_code code1 = ERROR_MARK;
1817   enum tree_code code2 = ERROR_MARK;
1818
1819   if (class1 == 'e' || class1 == '1'
1820       || class1 == '2' || class1 == '<')
1821     code1 = C_EXP_ORIGINAL_CODE (arg1);
1822   if (class2 == 'e' || class2 == '1'
1823       || class2 == '2' || class2 == '<')
1824     code2 = C_EXP_ORIGINAL_CODE (arg2);
1825
1826   /* Check for cases such as x+y<<z which users are likely
1827      to misinterpret.  If parens are used, C_EXP_ORIGINAL_CODE
1828      is cleared to prevent these warnings.  */
1829   if (warn_parentheses)
1830     {
1831       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1832         {
1833           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1834               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1835             warning ("suggest parentheses around + or - inside shift");
1836         }
1837
1838       if (code == TRUTH_ORIF_EXPR)
1839         {
1840           if (code1 == TRUTH_ANDIF_EXPR
1841               || code2 == TRUTH_ANDIF_EXPR)
1842             warning ("suggest parentheses around && within ||");
1843         }
1844
1845       if (code == BIT_IOR_EXPR)
1846         {
1847           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1848               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1849               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1850               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1851             warning ("suggest parentheses around arithmetic in operand of |");
1852           /* Check cases like x|y==z */
1853           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1854             warning ("suggest parentheses around comparison in operand of |");
1855         }
1856
1857       if (code == BIT_XOR_EXPR)
1858         {
1859           if (code1 == BIT_AND_EXPR
1860               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1861               || code2 == BIT_AND_EXPR
1862               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1863             warning ("suggest parentheses around arithmetic in operand of ^");
1864           /* Check cases like x^y==z */
1865           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1866             warning ("suggest parentheses around comparison in operand of ^");
1867         }
1868
1869       if (code == BIT_AND_EXPR)
1870         {
1871           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1872               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1873             warning ("suggest parentheses around + or - in operand of &");
1874           /* Check cases like x&y==z */
1875           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1876             warning ("suggest parentheses around comparison in operand of &");
1877         }
1878     }
1879
1880   /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
1881   if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1882       && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1883     warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1884
1885   unsigned_conversion_warning (result, arg1);
1886   unsigned_conversion_warning (result, arg2);
1887   overflow_warning (result);
1888
1889   class = TREE_CODE_CLASS (TREE_CODE (result));
1890
1891   /* Record the code that was specified in the source,
1892      for the sake of warnings about confusing nesting.  */
1893   if (class == 'e' || class == '1'
1894       || class == '2' || class == '<')
1895     C_SET_EXP_ORIGINAL_CODE (result, code);
1896   else
1897     {
1898       int flag = TREE_CONSTANT (result);
1899       /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1900          so that convert_for_assignment wouldn't strip it.
1901          That way, we got warnings for things like p = (1 - 1).
1902          But it turns out we should not get those warnings.  */
1903       result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1904       C_SET_EXP_ORIGINAL_CODE (result, code);
1905       TREE_CONSTANT (result) = flag;
1906     }
1907
1908   return result;
1909 }
1910
1911 /* Build a binary-operation expression without default conversions.
1912    CODE is the kind of expression to build.
1913    This function differs from `build' in several ways:
1914    the data type of the result is computed and recorded in it,
1915    warnings are generated if arg data types are invalid,
1916    special handling for addition and subtraction of pointers is known,
1917    and some optimization is done (operations on narrow ints
1918    are done in the narrower type when that gives the same result).
1919    Constant folding is also done before the result is returned.
1920
1921    Note that the operands will never have enumeral types, or function
1922    or array types, because either they will have the default conversions
1923    performed or they have both just been converted to some other type in which
1924    the arithmetic is to be done.  */
1925
1926 tree
1927 build_binary_op (code, orig_op0, orig_op1, convert_p)
1928      enum tree_code code;
1929      tree orig_op0, orig_op1;
1930      int convert_p;
1931 {
1932   tree type0, type1;
1933   register enum tree_code code0, code1;
1934   tree op0, op1;
1935
1936   /* Expression code to give to the expression when it is built.
1937      Normally this is CODE, which is what the caller asked for,
1938      but in some special cases we change it.  */
1939   register enum tree_code resultcode = code;
1940
1941   /* Data type in which the computation is to be performed.
1942      In the simplest cases this is the common type of the arguments.  */
1943   register tree result_type = NULL;
1944
1945   /* Nonzero means operands have already been type-converted
1946      in whatever way is necessary.
1947      Zero means they need to be converted to RESULT_TYPE.  */
1948   int converted = 0;
1949
1950   /* Nonzero means create the expression with this type, rather than
1951      RESULT_TYPE.  */
1952   tree build_type = 0;
1953
1954   /* Nonzero means after finally constructing the expression
1955      convert it to this type.  */
1956   tree final_type = 0;
1957
1958   /* Nonzero if this is an operation like MIN or MAX which can
1959      safely be computed in short if both args are promoted shorts.
1960      Also implies COMMON.
1961      -1 indicates a bitwise operation; this makes a difference
1962      in the exact conditions for when it is safe to do the operation
1963      in a narrower mode.  */
1964   int shorten = 0;
1965
1966   /* Nonzero if this is a comparison operation;
1967      if both args are promoted shorts, compare the original shorts.
1968      Also implies COMMON.  */
1969   int short_compare = 0;
1970
1971   /* Nonzero if this is a right-shift operation, which can be computed on the
1972      original short and then promoted if the operand is a promoted short.  */
1973   int short_shift = 0;
1974
1975   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
1976   int common = 0;
1977
1978   if (convert_p)
1979     {
1980       op0 = default_conversion (orig_op0);
1981       op1 = default_conversion (orig_op1);
1982     }
1983   else
1984     {
1985       op0 = orig_op0;
1986       op1 = orig_op1;
1987     }
1988
1989   type0 = TREE_TYPE (op0);
1990   type1 = TREE_TYPE (op1);
1991
1992   /* The expression codes of the data types of the arguments tell us
1993      whether the arguments are integers, floating, pointers, etc.  */
1994   code0 = TREE_CODE (type0);
1995   code1 = TREE_CODE (type1);
1996
1997   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1998   STRIP_TYPE_NOPS (op0);
1999   STRIP_TYPE_NOPS (op1);
2000
2001   /* If an error was already reported for one of the arguments,
2002      avoid reporting another error.  */
2003
2004   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2005     return error_mark_node;
2006
2007   switch (code)
2008     {
2009     case PLUS_EXPR:
2010       /* Handle the pointer + int case.  */
2011       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2012         return pointer_int_sum (PLUS_EXPR, op0, op1);
2013       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2014         return pointer_int_sum (PLUS_EXPR, op1, op0);
2015       else
2016         common = 1;
2017       break;
2018
2019     case MINUS_EXPR:
2020       /* Subtraction of two similar pointers.
2021          We must subtract them as integers, then divide by object size.  */
2022       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2023           && comp_target_types (type0, type1))
2024         return pointer_diff (op0, op1);
2025       /* Handle pointer minus int.  Just like pointer plus int.  */
2026       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2027         return pointer_int_sum (MINUS_EXPR, op0, op1);
2028       else
2029         common = 1;
2030       break;
2031
2032     case MULT_EXPR:
2033       common = 1;
2034       break;
2035
2036     case TRUNC_DIV_EXPR:
2037     case CEIL_DIV_EXPR:
2038     case FLOOR_DIV_EXPR:
2039     case ROUND_DIV_EXPR:
2040     case EXACT_DIV_EXPR:
2041       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2042            || code0 == COMPLEX_TYPE)
2043           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2044               || code1 == COMPLEX_TYPE))
2045         {
2046           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2047             resultcode = RDIV_EXPR;
2048           else
2049             /* Although it would be tempting to shorten always here, that
2050                loses on some targets, since the modulo instruction is
2051                undefined if the quotient can't be represented in the
2052                computation mode.  We shorten only if unsigned or if
2053                dividing by something we know != -1.  */
2054             shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2055                        || (TREE_CODE (op1) == INTEGER_CST
2056                            && ! integer_all_onesp (op1)));
2057           common = 1;
2058         }
2059       break;
2060
2061     case BIT_AND_EXPR:
2062     case BIT_ANDTC_EXPR:
2063     case BIT_IOR_EXPR:
2064     case BIT_XOR_EXPR:
2065       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2066         shorten = -1;
2067       /* If one operand is a constant, and the other is a short type
2068          that has been converted to an int,
2069          really do the work in the short type and then convert the
2070          result to int.  If we are lucky, the constant will be 0 or 1
2071          in the short type, making the entire operation go away.  */
2072       if (TREE_CODE (op0) == INTEGER_CST
2073           && TREE_CODE (op1) == NOP_EXPR
2074           && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2075           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2076         {
2077           final_type = result_type;
2078           op1 = TREE_OPERAND (op1, 0);
2079           result_type = TREE_TYPE (op1);
2080         }
2081       if (TREE_CODE (op1) == INTEGER_CST
2082           && TREE_CODE (op0) == NOP_EXPR
2083           && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2084           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2085         {
2086           final_type = result_type;
2087           op0 = TREE_OPERAND (op0, 0);
2088           result_type = TREE_TYPE (op0);
2089         }
2090       break;
2091
2092     case TRUNC_MOD_EXPR:
2093     case FLOOR_MOD_EXPR:
2094       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2095         {
2096           /* Although it would be tempting to shorten always here, that loses
2097              on some targets, since the modulo instruction is undefined if the
2098              quotient can't be represented in the computation mode.  We shorten
2099              only if unsigned or if dividing by something we know != -1.  */
2100           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2101                      || (TREE_CODE (op1) == INTEGER_CST
2102                          && ! integer_all_onesp (op1)));
2103           common = 1;
2104         }
2105       break;
2106
2107     case TRUTH_ANDIF_EXPR:
2108     case TRUTH_ORIF_EXPR:
2109     case TRUTH_AND_EXPR:
2110     case TRUTH_OR_EXPR:
2111     case TRUTH_XOR_EXPR:
2112       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2113            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2114           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2115               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2116         {
2117           /* Result of these operations is always an int,
2118              but that does not mean the operands should be
2119              converted to ints!  */
2120           result_type = integer_type_node;
2121           op0 = truthvalue_conversion (op0);
2122           op1 = truthvalue_conversion (op1);
2123           converted = 1;
2124         }
2125       break;
2126
2127       /* Shift operations: result has same type as first operand;
2128          always convert second operand to int.
2129          Also set SHORT_SHIFT if shifting rightward.  */
2130
2131     case RSHIFT_EXPR:
2132       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2133         {
2134           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2135             {
2136               if (tree_int_cst_sgn (op1) < 0)
2137                 warning ("right shift count is negative");
2138               else
2139                 {
2140                   if (! integer_zerop (op1))
2141                     short_shift = 1;
2142
2143                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2144                     warning ("right shift count >= width of type");
2145                 }
2146             }
2147
2148           /* Use the type of the value to be shifted.
2149              This is what most traditional C compilers do.  */
2150           result_type = type0;
2151           /* Unless traditional, convert the shift-count to an integer,
2152              regardless of size of value being shifted.  */
2153           if (! flag_traditional)
2154             {
2155               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2156                 op1 = convert (integer_type_node, op1);
2157               /* Avoid converting op1 to result_type later.  */
2158               converted = 1;
2159             }
2160         }
2161       break;
2162
2163     case LSHIFT_EXPR:
2164       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2165         {
2166           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2167             {
2168               if (tree_int_cst_sgn (op1) < 0)
2169                 warning ("left shift count is negative");
2170
2171               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2172                 warning ("left shift count >= width of type");
2173             }
2174
2175           /* Use the type of the value to be shifted.
2176              This is what most traditional C compilers do.  */
2177           result_type = type0;
2178           /* Unless traditional, convert the shift-count to an integer,
2179              regardless of size of value being shifted.  */
2180           if (! flag_traditional)
2181             {
2182               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2183                 op1 = convert (integer_type_node, op1);
2184               /* Avoid converting op1 to result_type later.  */
2185               converted = 1;
2186             }
2187         }
2188       break;
2189
2190     case RROTATE_EXPR:
2191     case LROTATE_EXPR:
2192       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2193         {
2194           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2195             {
2196               if (tree_int_cst_sgn (op1) < 0)
2197                 warning ("shift count is negative");
2198               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2199                 warning ("shift count >= width of type");
2200             }
2201
2202           /* Use the type of the value to be shifted.
2203              This is what most traditional C compilers do.  */
2204           result_type = type0;
2205           /* Unless traditional, convert the shift-count to an integer,
2206              regardless of size of value being shifted.  */
2207           if (! flag_traditional)
2208             {
2209               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2210                 op1 = convert (integer_type_node, op1);
2211               /* Avoid converting op1 to result_type later.  */
2212               converted = 1;
2213             }
2214         }
2215       break;
2216
2217     case EQ_EXPR:
2218     case NE_EXPR:
2219       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2220         warning ("comparing floating point with == or != is unsafe");
2221       /* Result of comparison is always int,
2222          but don't convert the args to int!  */
2223       build_type = integer_type_node;
2224       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2225            || code0 == COMPLEX_TYPE)
2226           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2227               || code1 == COMPLEX_TYPE))
2228         short_compare = 1;
2229       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2230         {
2231           register tree tt0 = TREE_TYPE (type0);
2232           register tree tt1 = TREE_TYPE (type1);
2233           /* Anything compares with void *.  void * compares with anything.
2234              Otherwise, the targets must be compatible
2235              and both must be object or both incomplete.  */
2236           if (comp_target_types (type0, type1))
2237             result_type = common_type (type0, type1);
2238           else if (VOID_TYPE_P (tt0))
2239             {
2240               /* op0 != orig_op0 detects the case of something
2241                  whose value is 0 but which isn't a valid null ptr const.  */
2242               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2243                   && TREE_CODE (tt1) == FUNCTION_TYPE)
2244                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2245             }
2246           else if (VOID_TYPE_P (tt1))
2247             {
2248               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2249                   && TREE_CODE (tt0) == FUNCTION_TYPE)
2250                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2251             }
2252           else
2253             pedwarn ("comparison of distinct pointer types lacks a cast");
2254
2255           if (result_type == NULL_TREE)
2256             result_type = ptr_type_node;
2257         }
2258       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2259                && integer_zerop (op1))
2260         result_type = type0;
2261       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2262                && integer_zerop (op0))
2263         result_type = type1;
2264       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2265         {
2266           result_type = type0;
2267           if (! flag_traditional)
2268             pedwarn ("comparison between pointer and integer");
2269         }
2270       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2271         {
2272           result_type = type1;
2273           if (! flag_traditional)
2274             pedwarn ("comparison between pointer and integer");
2275         }
2276       break;
2277
2278     case MAX_EXPR:
2279     case MIN_EXPR:
2280       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2281           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2282         shorten = 1;
2283       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2284         {
2285           if (comp_target_types (type0, type1))
2286             {
2287               result_type = common_type (type0, type1);
2288               if (pedantic
2289                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2290                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2291             }
2292           else
2293             {
2294               result_type = ptr_type_node;
2295               pedwarn ("comparison of distinct pointer types lacks a cast");
2296             }
2297         }
2298       break;
2299
2300     case LE_EXPR:
2301     case GE_EXPR:
2302     case LT_EXPR:
2303     case GT_EXPR:
2304       build_type = integer_type_node;
2305       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2306           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2307         short_compare = 1;
2308       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2309         {
2310           if (comp_target_types (type0, type1))
2311             {
2312               result_type = common_type (type0, type1);
2313               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2314                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2315                 pedwarn ("comparison of complete and incomplete pointers");
2316               else if (pedantic
2317                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2318                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2319             }
2320           else
2321             {
2322               result_type = ptr_type_node;
2323               pedwarn ("comparison of distinct pointer types lacks a cast");
2324             }
2325         }
2326       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2327                && integer_zerop (op1))
2328         {
2329           result_type = type0;
2330           if (pedantic || extra_warnings)
2331             pedwarn ("ordered comparison of pointer with integer zero");
2332         }
2333       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2334                && integer_zerop (op0))
2335         {
2336           result_type = type1;
2337           if (pedantic)
2338             pedwarn ("ordered comparison of pointer with integer zero");
2339         }
2340       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2341         {
2342           result_type = type0;
2343           if (! flag_traditional)
2344             pedwarn ("comparison between pointer and integer");
2345         }
2346       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2347         {
2348           result_type = type1;
2349           if (! flag_traditional)
2350             pedwarn ("comparison between pointer and integer");
2351         }
2352       break;
2353
2354     case UNORDERED_EXPR:
2355     case ORDERED_EXPR:
2356     case UNLT_EXPR:
2357     case UNLE_EXPR:
2358     case UNGT_EXPR:
2359     case UNGE_EXPR:
2360     case UNEQ_EXPR:
2361       build_type = integer_type_node;
2362       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2363         {
2364           error ("unordered comparison on non-floating point argument");
2365           return error_mark_node;
2366         }
2367       common = 1;
2368       break;
2369
2370     default:
2371       break;
2372     }
2373
2374   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2375       &&
2376       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2377     {
2378       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2379
2380       if (shorten || common || short_compare)
2381         result_type = common_type (type0, type1);
2382
2383       /* For certain operations (which identify themselves by shorten != 0)
2384          if both args were extended from the same smaller type,
2385          do the arithmetic in that type and then extend.
2386
2387          shorten !=0 and !=1 indicates a bitwise operation.
2388          For them, this optimization is safe only if
2389          both args are zero-extended or both are sign-extended.
2390          Otherwise, we might change the result.
2391          Eg, (short)-1 | (unsigned short)-1 is (int)-1
2392          but calculated in (unsigned short) it would be (unsigned short)-1.  */
2393
2394       if (shorten && none_complex)
2395         {
2396           int unsigned0, unsigned1;
2397           tree arg0 = get_narrower (op0, &unsigned0);
2398           tree arg1 = get_narrower (op1, &unsigned1);
2399           /* UNS is 1 if the operation to be done is an unsigned one.  */
2400           int uns = TREE_UNSIGNED (result_type);
2401           tree type;
2402
2403           final_type = result_type;
2404
2405           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2406              but it *requires* conversion to FINAL_TYPE.  */
2407
2408           if ((TYPE_PRECISION (TREE_TYPE (op0))
2409                == TYPE_PRECISION (TREE_TYPE (arg0)))
2410               && TREE_TYPE (op0) != final_type)
2411             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2412           if ((TYPE_PRECISION (TREE_TYPE (op1))
2413                == TYPE_PRECISION (TREE_TYPE (arg1)))
2414               && TREE_TYPE (op1) != final_type)
2415             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2416
2417           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
2418
2419           /* For bitwise operations, signedness of nominal type
2420              does not matter.  Consider only how operands were extended.  */
2421           if (shorten == -1)
2422             uns = unsigned0;
2423
2424           /* Note that in all three cases below we refrain from optimizing
2425              an unsigned operation on sign-extended args.
2426              That would not be valid.  */
2427
2428           /* Both args variable: if both extended in same way
2429              from same width, do it in that width.
2430              Do it unsigned if args were zero-extended.  */
2431           if ((TYPE_PRECISION (TREE_TYPE (arg0))
2432                < TYPE_PRECISION (result_type))
2433               && (TYPE_PRECISION (TREE_TYPE (arg1))
2434                   == TYPE_PRECISION (TREE_TYPE (arg0)))
2435               && unsigned0 == unsigned1
2436               && (unsigned0 || !uns))
2437             result_type
2438               = signed_or_unsigned_type (unsigned0,
2439                                          common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2440           else if (TREE_CODE (arg0) == INTEGER_CST
2441                    && (unsigned1 || !uns)
2442                    && (TYPE_PRECISION (TREE_TYPE (arg1))
2443                        < TYPE_PRECISION (result_type))
2444                    && (type = signed_or_unsigned_type (unsigned1,
2445                                                        TREE_TYPE (arg1)),
2446                        int_fits_type_p (arg0, type)))
2447             result_type = type;
2448           else if (TREE_CODE (arg1) == INTEGER_CST
2449                    && (unsigned0 || !uns)
2450                    && (TYPE_PRECISION (TREE_TYPE (arg0))
2451                        < TYPE_PRECISION (result_type))
2452                    && (type = signed_or_unsigned_type (unsigned0,
2453                                                        TREE_TYPE (arg0)),
2454                        int_fits_type_p (arg1, type)))
2455             result_type = type;
2456         }
2457
2458       /* Shifts can be shortened if shifting right.  */
2459
2460       if (short_shift)
2461         {
2462           int unsigned_arg;
2463           tree arg0 = get_narrower (op0, &unsigned_arg);
2464
2465           final_type = result_type;
2466
2467           if (arg0 == op0 && final_type == TREE_TYPE (op0))
2468             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2469
2470           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2471               /* We can shorten only if the shift count is less than the
2472                  number of bits in the smaller type size.  */
2473               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2474               /* If arg is sign-extended and then unsigned-shifted,
2475                  we can simulate this with a signed shift in arg's type
2476                  only if the extended result is at least twice as wide
2477                  as the arg.  Otherwise, the shift could use up all the
2478                  ones made by sign-extension and bring in zeros.
2479                  We can't optimize that case at all, but in most machines
2480                  it never happens because available widths are 2**N.  */
2481               && (!TREE_UNSIGNED (final_type)
2482                   || unsigned_arg
2483                   || (2 * TYPE_PRECISION (TREE_TYPE (arg0))
2484                       <= TYPE_PRECISION (result_type))))
2485             {
2486               /* Do an unsigned shift if the operand was zero-extended.  */
2487               result_type
2488                 = signed_or_unsigned_type (unsigned_arg,
2489                                            TREE_TYPE (arg0));
2490               /* Convert value-to-be-shifted to that type.  */
2491               if (TREE_TYPE (op0) != result_type)
2492                 op0 = convert (result_type, op0);
2493               converted = 1;
2494             }
2495         }
2496
2497       /* Comparison operations are shortened too but differently.
2498          They identify themselves by setting short_compare = 1.  */
2499
2500       if (short_compare)
2501         {
2502           /* Don't write &op0, etc., because that would prevent op0
2503              from being kept in a register.
2504              Instead, make copies of the our local variables and
2505              pass the copies by reference, then copy them back afterward.  */
2506           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2507           enum tree_code xresultcode = resultcode;
2508           tree val
2509             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2510
2511           if (val != 0)
2512             return val;
2513
2514           op0 = xop0, op1 = xop1;
2515           converted = 1;
2516           resultcode = xresultcode;
2517
2518           if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2519               && skip_evaluation == 0)
2520             {
2521               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2522               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2523               int unsignedp0, unsignedp1;
2524               tree primop0 = get_narrower (op0, &unsignedp0);
2525               tree primop1 = get_narrower (op1, &unsignedp1);
2526
2527               xop0 = orig_op0;
2528               xop1 = orig_op1;
2529               STRIP_TYPE_NOPS (xop0);
2530               STRIP_TYPE_NOPS (xop1);
2531
2532               /* Give warnings for comparisons between signed and unsigned
2533                  quantities that may fail.
2534
2535                  Do the checking based on the original operand trees, so that
2536                  casts will be considered, but default promotions won't be.
2537
2538                  Do not warn if the comparison is being done in a signed type,
2539                  since the signed type will only be chosen if it can represent
2540                  all the values of the unsigned type.  */
2541               if (! TREE_UNSIGNED (result_type))
2542                 /* OK */;
2543               /* Do not warn if both operands are the same signedness.  */
2544               else if (op0_signed == op1_signed)
2545                 /* OK */;
2546               else
2547                 {
2548                   tree sop, uop;
2549
2550                   if (op0_signed)
2551                     sop = xop0, uop = xop1;
2552                   else
2553                     sop = xop1, uop = xop0;
2554
2555                   /* Do not warn if the signed quantity is an
2556                      unsuffixed integer literal (or some static
2557                      constant expression involving such literals or a
2558                      conditional expression involving such literals)
2559                      and it is non-negative.  */
2560                   if (tree_expr_nonnegative_p (sop))
2561                     /* OK */;
2562                   /* Do not warn if the comparison is an equality operation,
2563                      the unsigned quantity is an integral constant, and it
2564                      would fit in the result if the result were signed.  */
2565                   else if (TREE_CODE (uop) == INTEGER_CST
2566                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2567                            && int_fits_type_p (uop, signed_type (result_type)))
2568                     /* OK */;
2569                   /* Do not warn if the unsigned quantity is an enumeration
2570                      constant and its maximum value would fit in the result
2571                      if the result were signed.  */
2572                   else if (TREE_CODE (uop) == INTEGER_CST
2573                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2574                            && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2575                                                signed_type (result_type)))
2576                     /* OK */;
2577                   else
2578                     warning ("comparison between signed and unsigned");
2579                 }
2580
2581               /* Warn if two unsigned values are being compared in a size
2582                  larger than their original size, and one (and only one) is the
2583                  result of a `~' operator.  This comparison will always fail.
2584
2585                  Also warn if one operand is a constant, and the constant
2586                  does not have all bits set that are set in the ~ operand
2587                  when it is extended.  */
2588
2589               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2590                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2591                 {
2592                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2593                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2594                                             &unsignedp0);
2595                   else
2596                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2597                                             &unsignedp1);
2598
2599                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2600                     {
2601                       tree primop;
2602                       HOST_WIDE_INT constant, mask;
2603                       int unsignedp, bits;
2604
2605                       if (host_integerp (primop0, 0))
2606                         {
2607                           primop = primop1;
2608                           unsignedp = unsignedp1;
2609                           constant = tree_low_cst (primop0, 0);
2610                         }
2611                       else
2612                         {
2613                           primop = primop0;
2614                           unsignedp = unsignedp0;
2615                           constant = tree_low_cst (primop1, 0);
2616                         }
2617
2618                       bits = TYPE_PRECISION (TREE_TYPE (primop));
2619                       if (bits < TYPE_PRECISION (result_type)
2620                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2621                         {
2622                           mask = (~ (HOST_WIDE_INT) 0) << bits;
2623                           if ((mask & constant) != mask)
2624                             warning ("comparison of promoted ~unsigned with constant");
2625                         }
2626                     }
2627                   else if (unsignedp0 && unsignedp1
2628                            && (TYPE_PRECISION (TREE_TYPE (primop0))
2629                                < TYPE_PRECISION (result_type))
2630                            && (TYPE_PRECISION (TREE_TYPE (primop1))
2631                                < TYPE_PRECISION (result_type)))
2632                     warning ("comparison of promoted ~unsigned with unsigned");
2633                 }
2634             }
2635         }
2636     }
2637
2638   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2639      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2640      Then the expression will be built.
2641      It will be given type FINAL_TYPE if that is nonzero;
2642      otherwise, it will be given type RESULT_TYPE.  */
2643
2644   if (!result_type)
2645     {
2646       binary_op_error (code);
2647       return error_mark_node;
2648     }
2649
2650   if (! converted)
2651     {
2652       if (TREE_TYPE (op0) != result_type)
2653         op0 = convert (result_type, op0);
2654       if (TREE_TYPE (op1) != result_type)
2655         op1 = convert (result_type, op1);
2656     }
2657
2658   if (build_type == NULL_TREE)
2659     build_type = result_type;
2660
2661   {
2662     register tree result = build (resultcode, build_type, op0, op1);
2663     register tree folded;
2664
2665     folded = fold (result);
2666     if (folded == result)
2667       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2668     if (final_type != 0)
2669       return convert (final_type, folded);
2670     return folded;
2671   }
2672 }
2673 \f
2674 /* Return a tree for the sum or difference (RESULTCODE says which)
2675    of pointer PTROP and integer INTOP.  */
2676
2677 static tree
2678 pointer_int_sum (resultcode, ptrop, intop)
2679      enum tree_code resultcode;
2680      register tree ptrop, intop;
2681 {
2682   tree size_exp;
2683
2684   register tree result;
2685   register tree folded;
2686
2687   /* The result is a pointer of the same type that is being added.  */
2688
2689   register tree result_type = TREE_TYPE (ptrop);
2690
2691   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2692     {
2693       if (pedantic || warn_pointer_arith)
2694         pedwarn ("pointer of type `void *' used in arithmetic");
2695       size_exp = integer_one_node;
2696     }
2697   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2698     {
2699       if (pedantic || warn_pointer_arith)
2700         pedwarn ("pointer to a function used in arithmetic");
2701       size_exp = integer_one_node;
2702     }
2703   else
2704     size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2705
2706   /* If what we are about to multiply by the size of the elements
2707      contains a constant term, apply distributive law
2708      and multiply that constant term separately.
2709      This helps produce common subexpressions.  */
2710
2711   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2712       && ! TREE_CONSTANT (intop)
2713       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2714       && TREE_CONSTANT (size_exp)
2715       /* If the constant comes from pointer subtraction,
2716          skip this optimization--it would cause an error.  */
2717       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2718       /* If the constant is unsigned, and smaller than the pointer size,
2719          then we must skip this optimization.  This is because it could cause
2720          an overflow error if the constant is negative but INTOP is not.  */
2721       && (! TREE_UNSIGNED (TREE_TYPE (intop))
2722           || (TYPE_PRECISION (TREE_TYPE (intop))
2723               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2724     {
2725       enum tree_code subcode = resultcode;
2726       tree int_type = TREE_TYPE (intop);
2727       if (TREE_CODE (intop) == MINUS_EXPR)
2728         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2729       /* Convert both subexpression types to the type of intop,
2730          because weird cases involving pointer arithmetic
2731          can result in a sum or difference with different type args.  */
2732       ptrop = build_binary_op (subcode, ptrop,
2733                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2734       intop = convert (int_type, TREE_OPERAND (intop, 0));
2735     }
2736
2737   /* Convert the integer argument to a type the same size as sizetype
2738      so the multiply won't overflow spuriously.  */
2739
2740   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2741       || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2742     intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2743                                     TREE_UNSIGNED (sizetype)), intop);
2744
2745   /* Replace the integer argument with a suitable product by the object size.
2746      Do this multiplication as signed, then convert to the appropriate
2747      pointer type (actually unsigned integral).  */
2748
2749   intop = convert (result_type,
2750                    build_binary_op (MULT_EXPR, intop,
2751                                     convert (TREE_TYPE (intop), size_exp), 1));
2752
2753   /* Create the sum or difference.  */
2754
2755   result = build (resultcode, result_type, ptrop, intop);
2756
2757   folded = fold (result);
2758   if (folded == result)
2759     TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2760   return folded;
2761 }
2762
2763 /* Return a tree for the difference of pointers OP0 and OP1.
2764    The resulting tree has type int.  */
2765
2766 static tree
2767 pointer_diff (op0, op1)
2768      register tree op0, op1;
2769 {
2770   register tree result, folded;
2771   tree restype = ptrdiff_type_node;
2772
2773   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2774
2775   if (pedantic || warn_pointer_arith)
2776     {
2777       if (TREE_CODE (target_type) == VOID_TYPE)
2778         pedwarn ("pointer of type `void *' used in subtraction");
2779       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2780         pedwarn ("pointer to a function used in subtraction");
2781     }
2782
2783   /* First do the subtraction as integers;
2784      then drop through to build the divide operator.
2785      Do not do default conversions on the minus operator
2786      in case restype is a short type.  */
2787
2788   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2789                          convert (restype, op1), 0);
2790   /* This generates an error if op1 is pointer to incomplete type.  */
2791   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
2792     error ("arithmetic on pointer to an incomplete type");
2793
2794   /* This generates an error if op0 is pointer to incomplete type.  */
2795   op1 = c_size_in_bytes (target_type);
2796
2797   /* Divide by the size, in easiest possible way.  */
2798
2799   result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2800
2801   folded = fold (result);
2802   if (folded == result)
2803     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2804   return folded;
2805 }
2806 \f
2807 /* Construct and perhaps optimize a tree representation
2808    for a unary operation.  CODE, a tree_code, specifies the operation
2809    and XARG is the operand.  NOCONVERT nonzero suppresses
2810    the default promotions (such as from short to int).  */
2811
2812 tree
2813 build_unary_op (code, xarg, noconvert)
2814      enum tree_code code;
2815      tree xarg;
2816      int noconvert;
2817 {
2818   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2819   register tree arg = xarg;
2820   register tree argtype = 0;
2821   register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2822   tree val;
2823
2824   if (typecode == ERROR_MARK)
2825     return error_mark_node;
2826   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2827     typecode = INTEGER_TYPE;
2828
2829   switch (code)
2830     {
2831     case CONVERT_EXPR:
2832       /* This is used for unary plus, because a CONVERT_EXPR
2833          is enough to prevent anybody from looking inside for
2834          associativity, but won't generate any code.  */
2835       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2836             || typecode == COMPLEX_TYPE))
2837         {
2838           error ("wrong type argument to unary plus");
2839           return error_mark_node;
2840         }
2841       else if (!noconvert)
2842         arg = default_conversion (arg);
2843       break;
2844
2845     case NEGATE_EXPR:
2846       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2847             || typecode == COMPLEX_TYPE))
2848         {
2849           error ("wrong type argument to unary minus");
2850           return error_mark_node;
2851         }
2852       else if (!noconvert)
2853         arg = default_conversion (arg);
2854       break;
2855
2856     case BIT_NOT_EXPR:
2857       if (typecode == COMPLEX_TYPE)
2858         {
2859           code = CONJ_EXPR;
2860           if (pedantic)
2861             pedwarn ("ISO C does not support `~' for complex conjugation");
2862           if (!noconvert)
2863             arg = default_conversion (arg);
2864         }
2865       else if (typecode != INTEGER_TYPE)
2866         {
2867           error ("wrong type argument to bit-complement");
2868           return error_mark_node;
2869         }
2870       else if (!noconvert)
2871         arg = default_conversion (arg);
2872       break;
2873
2874     case ABS_EXPR:
2875       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2876             || typecode == COMPLEX_TYPE))
2877         {
2878           error ("wrong type argument to abs");
2879           return error_mark_node;
2880         }
2881       else if (!noconvert)
2882         arg = default_conversion (arg);
2883       break;
2884
2885     case CONJ_EXPR:
2886       /* Conjugating a real value is a no-op, but allow it anyway.  */
2887       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2888             || typecode == COMPLEX_TYPE))
2889         {
2890           error ("wrong type argument to conjugation");
2891           return error_mark_node;
2892         }
2893       else if (!noconvert)
2894         arg = default_conversion (arg);
2895       break;
2896
2897     case TRUTH_NOT_EXPR:
2898       if (typecode != INTEGER_TYPE
2899           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2900           && typecode != COMPLEX_TYPE
2901           /* These will convert to a pointer.  */
2902           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2903         {
2904           error ("wrong type argument to unary exclamation mark");
2905           return error_mark_node;
2906         }
2907       arg = truthvalue_conversion (arg);
2908       return invert_truthvalue (arg);
2909
2910     case NOP_EXPR:
2911       break;
2912
2913     case REALPART_EXPR:
2914       if (TREE_CODE (arg) == COMPLEX_CST)
2915         return TREE_REALPART (arg);
2916       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2917         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2918       else
2919         return arg;
2920
2921     case IMAGPART_EXPR:
2922       if (TREE_CODE (arg) == COMPLEX_CST)
2923         return TREE_IMAGPART (arg);
2924       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2925         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2926       else
2927         return convert (TREE_TYPE (arg), integer_zero_node);
2928
2929     case PREINCREMENT_EXPR:
2930     case POSTINCREMENT_EXPR:
2931     case PREDECREMENT_EXPR:
2932     case POSTDECREMENT_EXPR:
2933       /* Handle complex lvalues (when permitted)
2934          by reduction to simpler cases.  */
2935
2936       val = unary_complex_lvalue (code, arg);
2937       if (val != 0)
2938         return val;
2939
2940       /* Increment or decrement the real part of the value,
2941          and don't change the imaginary part.  */
2942       if (typecode == COMPLEX_TYPE)
2943         {
2944           tree real, imag;
2945
2946           if (pedantic)
2947             pedwarn ("ISO C does not support `++' and `--' on complex types");
2948
2949           arg = stabilize_reference (arg);
2950           real = build_unary_op (REALPART_EXPR, arg, 1);
2951           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2952           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2953                         build_unary_op (code, real, 1), imag);
2954         }
2955
2956       /* Report invalid types.  */
2957
2958       if (typecode != POINTER_TYPE
2959           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2960         {
2961           error ("wrong type argument to %s",
2962                  code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2963                  ? "increment" : "decrement");
2964           return error_mark_node;
2965         }
2966
2967       {
2968         register tree inc;
2969         tree result_type = TREE_TYPE (arg);
2970
2971         arg = get_unwidened (arg, 0);
2972         argtype = TREE_TYPE (arg);
2973
2974         /* Compute the increment.  */
2975
2976         if (typecode == POINTER_TYPE)
2977           {
2978             /* If pointer target is an undefined struct,
2979                we just cannot know how to do the arithmetic.  */
2980             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2981               error ("%s of pointer to unknown structure",
2982                      code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2983                      ? "increment" : "decrement");
2984             else if ((pedantic || warn_pointer_arith)
2985                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2986                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2987               pedwarn ("wrong type argument to %s",
2988                        code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2989                        ? "increment" : "decrement");
2990             inc = c_size_in_bytes (TREE_TYPE (result_type));
2991           }
2992         else
2993           inc = integer_one_node;
2994
2995         inc = convert (argtype, inc);
2996
2997         /* Handle incrementing a cast-expression.  */
2998
2999         while (1)
3000           switch (TREE_CODE (arg))
3001             {
3002             case NOP_EXPR:
3003             case CONVERT_EXPR:
3004             case FLOAT_EXPR:
3005             case FIX_TRUNC_EXPR:
3006             case FIX_FLOOR_EXPR:
3007             case FIX_ROUND_EXPR:
3008             case FIX_CEIL_EXPR:
3009               pedantic_lvalue_warning (CONVERT_EXPR);
3010               /* If the real type has the same machine representation
3011                  as the type it is cast to, we can make better output
3012                  by adding directly to the inside of the cast.  */
3013               if ((TREE_CODE (TREE_TYPE (arg))
3014                    == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
3015                   && (TYPE_MODE (TREE_TYPE (arg))
3016                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
3017                 arg = TREE_OPERAND (arg, 0);
3018               else
3019                 {
3020                   tree incremented, modify, value;
3021                   if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3022                     value = boolean_increment (code, arg);
3023                   else
3024                     {
3025                       arg = stabilize_reference (arg);
3026                       if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3027                         value = arg;
3028                       else
3029                         value = save_expr (arg);
3030                       incremented = build (((code == PREINCREMENT_EXPR
3031                                              || code == POSTINCREMENT_EXPR)
3032                                             ? PLUS_EXPR : MINUS_EXPR),
3033                                            argtype, value, inc);
3034                       TREE_SIDE_EFFECTS (incremented) = 1;
3035                       modify = build_modify_expr (arg, NOP_EXPR, incremented);
3036                       value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3037                     }
3038                   TREE_USED (value) = 1;
3039                   return value;
3040                 }
3041               break;
3042
3043             default:
3044               goto give_up;
3045             }
3046       give_up:
3047
3048         /* Complain about anything else that is not a true lvalue.  */
3049         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3050                                     || code == POSTINCREMENT_EXPR)
3051                                    ? "invalid lvalue in increment"
3052                                    : "invalid lvalue in decrement")))
3053           return error_mark_node;
3054
3055         /* Report a read-only lvalue.  */
3056         if (TREE_READONLY (arg))
3057           readonly_warning (arg,
3058                             ((code == PREINCREMENT_EXPR
3059                               || code == POSTINCREMENT_EXPR)
3060                              ? "increment" : "decrement"));
3061
3062         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3063           val = boolean_increment (code, arg);
3064         else
3065           val = build (code, TREE_TYPE (arg), arg, inc);
3066         TREE_SIDE_EFFECTS (val) = 1;
3067         val = convert (result_type, val);
3068         if (TREE_CODE (val) != code)
3069           TREE_NO_UNUSED_WARNING (val) = 1;
3070         return val;
3071       }
3072
3073     case ADDR_EXPR:
3074       /* Note that this operation never does default_conversion
3075          regardless of NOCONVERT.  */
3076
3077       /* Let &* cancel out to simplify resulting code.  */
3078       if (TREE_CODE (arg) == INDIRECT_REF)
3079         {
3080           /* Don't let this be an lvalue.  */
3081           if (lvalue_p (TREE_OPERAND (arg, 0)))
3082             return non_lvalue (TREE_OPERAND (arg, 0));
3083           return TREE_OPERAND (arg, 0);
3084         }
3085
3086       /* For &x[y], return x+y */
3087       if (TREE_CODE (arg) == ARRAY_REF)
3088         {
3089           if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3090             return error_mark_node;
3091           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3092                                   TREE_OPERAND (arg, 1), 1);
3093         }
3094
3095       /* Handle complex lvalues (when permitted)
3096          by reduction to simpler cases.  */
3097       val = unary_complex_lvalue (code, arg);
3098       if (val != 0)
3099         return val;
3100
3101 #if 0 /* Turned off because inconsistent;
3102          float f; *&(int)f = 3.4 stores in int format
3103          whereas (int)f = 3.4 stores in float format.  */
3104       /* Address of a cast is just a cast of the address
3105          of the operand of the cast.  */
3106       switch (TREE_CODE (arg))
3107         {
3108         case NOP_EXPR:
3109         case CONVERT_EXPR:
3110         case FLOAT_EXPR:
3111         case FIX_TRUNC_EXPR:
3112         case FIX_FLOOR_EXPR:
3113         case FIX_ROUND_EXPR:
3114         case FIX_CEIL_EXPR:
3115           if (pedantic)
3116             pedwarn ("ISO C forbids the address of a cast expression");
3117           return convert (build_pointer_type (TREE_TYPE (arg)),
3118                           build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3119                                           0));
3120         }
3121 #endif
3122
3123       /* Allow the address of a constructor if all the elements
3124          are constant.  */
3125       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3126         ;
3127       /* Anything not already handled and not a true memory reference
3128          is an error.  */
3129       else if (typecode != FUNCTION_TYPE
3130                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3131         return error_mark_node;
3132
3133       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
3134       argtype = TREE_TYPE (arg);
3135
3136       /* If the lvalue is const or volatile, merge that into the type
3137          to which the address will point.  Note that you can't get a
3138          restricted pointer by taking the address of something, so we
3139          only have to deal with `const' and `volatile' here.  */
3140       if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3141           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3142           argtype = c_build_type_variant (argtype,
3143                                           TREE_READONLY (arg),
3144                                           TREE_THIS_VOLATILE (arg));
3145
3146       argtype = build_pointer_type (argtype);
3147
3148       if (mark_addressable (arg) == 0)
3149         return error_mark_node;
3150
3151       {
3152         tree addr;
3153
3154         if (TREE_CODE (arg) == COMPONENT_REF)
3155           {
3156             tree field = TREE_OPERAND (arg, 1);
3157
3158             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3159
3160             if (DECL_C_BIT_FIELD (field))
3161               {
3162                 error ("attempt to take address of bit-field structure member `%s'",
3163                        IDENTIFIER_POINTER (DECL_NAME (field)));
3164                 return error_mark_node;
3165               }
3166
3167             addr = fold (build (PLUS_EXPR, argtype,
3168                                 convert (argtype, addr),
3169                                 convert (argtype, byte_position (field))));
3170           }
3171         else
3172           addr = build1 (code, argtype, arg);
3173
3174         /* Address of a static or external variable or
3175            file-scope function counts as a constant.  */
3176         if (staticp (arg)
3177             && ! (TREE_CODE (arg) == FUNCTION_DECL
3178                   && DECL_CONTEXT (arg) != 0))
3179           TREE_CONSTANT (addr) = 1;
3180         return addr;
3181       }
3182
3183     default:
3184       break;
3185     }
3186
3187   if (argtype == 0)
3188     argtype = TREE_TYPE (arg);
3189   return fold (build1 (code, argtype, arg));
3190 }
3191
3192 #if 0
3193 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3194    convert ARG with the same conversions in the same order
3195    and return the result.  */
3196
3197 static tree
3198 convert_sequence (conversions, arg)
3199      tree conversions;
3200      tree arg;
3201 {
3202   switch (TREE_CODE (conversions))
3203     {
3204     case NOP_EXPR:
3205     case CONVERT_EXPR:
3206     case FLOAT_EXPR:
3207     case FIX_TRUNC_EXPR:
3208     case FIX_FLOOR_EXPR:
3209     case FIX_ROUND_EXPR:
3210     case FIX_CEIL_EXPR:
3211       return convert (TREE_TYPE (conversions),
3212                       convert_sequence (TREE_OPERAND (conversions, 0),
3213                                         arg));
3214
3215     default:
3216       return arg;
3217     }
3218 }
3219 #endif /* 0 */
3220
3221 /* Return nonzero if REF is an lvalue valid for this language.
3222    Lvalues can be assigned, unless their type has TYPE_READONLY.
3223    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
3224
3225 int
3226 lvalue_p (ref)
3227      tree ref;
3228 {
3229   register enum tree_code code = TREE_CODE (ref);
3230
3231   switch (code)
3232     {
3233     case REALPART_EXPR:
3234     case IMAGPART_EXPR:
3235     case COMPONENT_REF:
3236       return lvalue_p (TREE_OPERAND (ref, 0));
3237
3238     case STRING_CST:
3239       return 1;
3240
3241     case INDIRECT_REF:
3242     case ARRAY_REF:
3243     case VAR_DECL:
3244     case PARM_DECL:
3245     case RESULT_DECL:
3246     case ERROR_MARK:
3247       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3248               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3249
3250     case BIND_EXPR:
3251     case RTL_EXPR:
3252       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3253
3254     default:
3255       return 0;
3256     }
3257 }
3258
3259 /* Return nonzero if REF is an lvalue valid for this language;
3260    otherwise, print an error message and return zero.  */
3261
3262 int
3263 lvalue_or_else (ref, msgid)
3264      tree ref;
3265      const char *msgid;
3266 {
3267   int win = lvalue_p (ref);
3268
3269   if (! win)
3270     error ("%s", msgid);
3271
3272   return win;
3273 }
3274
3275 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3276    for certain kinds of expressions which are not really lvalues
3277    but which we can accept as lvalues.
3278
3279    If ARG is not a kind of expression we can handle, return zero.  */
3280
3281 static tree
3282 unary_complex_lvalue (code, arg)
3283      enum tree_code code;
3284      tree arg;
3285 {
3286   /* Handle (a, b) used as an "lvalue".  */
3287   if (TREE_CODE (arg) == COMPOUND_EXPR)
3288     {
3289       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3290
3291       /* If this returns a function type, it isn't really being used as
3292          an lvalue, so don't issue a warning about it.  */
3293       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3294         pedantic_lvalue_warning (COMPOUND_EXPR);
3295
3296       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3297                     TREE_OPERAND (arg, 0), real_result);
3298     }
3299
3300   /* Handle (a ? b : c) used as an "lvalue".  */
3301   if (TREE_CODE (arg) == COND_EXPR)
3302     {
3303       pedantic_lvalue_warning (COND_EXPR);
3304       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3305         pedantic_lvalue_warning (COMPOUND_EXPR);
3306
3307       return (build_conditional_expr
3308               (TREE_OPERAND (arg, 0),
3309                build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3310                build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3311     }
3312
3313   return 0;
3314 }
3315
3316 /* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
3317    COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
3318
3319 static void
3320 pedantic_lvalue_warning (code)
3321      enum tree_code code;
3322 {
3323   if (pedantic)
3324     switch (code)
3325       {
3326       case COND_EXPR:
3327         pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3328         break;
3329       case COMPOUND_EXPR:
3330         pedwarn ("ISO C forbids use of compound expressions as lvalues");
3331         break;
3332       default:
3333         pedwarn ("ISO C forbids use of cast expressions as lvalues");
3334         break;
3335       }
3336 }
3337 \f
3338 /* Warn about storing in something that is `const'.  */
3339
3340 void
3341 readonly_warning (arg, msgid)
3342      tree arg;
3343      const char *msgid;
3344 {
3345   if (TREE_CODE (arg) == COMPONENT_REF)
3346     {
3347       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3348         readonly_warning (TREE_OPERAND (arg, 0), msgid);
3349       else
3350         pedwarn ("%s of read-only member `%s'", _(msgid),
3351                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3352     }
3353   else if (TREE_CODE (arg) == VAR_DECL)
3354     pedwarn ("%s of read-only variable `%s'", _(msgid),
3355              IDENTIFIER_POINTER (DECL_NAME (arg)));
3356   else
3357     pedwarn ("%s of read-only location", _(msgid));
3358 }
3359 \f
3360 /* Mark EXP saying that we need to be able to take the
3361    address of it; it should not be allocated in a register.
3362    Value is 1 if successful.  */
3363
3364 int
3365 mark_addressable (exp)
3366      tree exp;
3367 {
3368   register tree x = exp;
3369   while (1)
3370     switch (TREE_CODE (x))
3371       {
3372       case COMPONENT_REF:
3373         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3374           {
3375             error ("cannot take address of bitfield `%s'",
3376                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3377             return 0;
3378           }
3379
3380         /* ... fall through ...  */
3381
3382       case ADDR_EXPR:
3383       case ARRAY_REF:
3384       case REALPART_EXPR:
3385       case IMAGPART_EXPR:
3386         x = TREE_OPERAND (x, 0);
3387         break;
3388
3389       case CONSTRUCTOR:
3390         TREE_ADDRESSABLE (x) = 1;
3391         return 1;
3392
3393       case VAR_DECL:
3394       case CONST_DECL:
3395       case PARM_DECL:
3396       case RESULT_DECL:
3397         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3398             && DECL_NONLOCAL (x))
3399           {
3400             if (TREE_PUBLIC (x))
3401               {
3402                 error ("global register variable `%s' used in nested function",
3403                        IDENTIFIER_POINTER (DECL_NAME (x)));
3404                 return 0;
3405               }
3406             pedwarn ("register variable `%s' used in nested function",
3407                      IDENTIFIER_POINTER (DECL_NAME (x)));
3408           }
3409         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3410           {
3411             if (TREE_PUBLIC (x))
3412               {
3413                 error ("address of global register variable `%s' requested",
3414                        IDENTIFIER_POINTER (DECL_NAME (x)));
3415                 return 0;
3416               }
3417
3418             /* If we are making this addressable due to its having
3419                volatile components, give a different error message.  Also
3420                handle the case of an unnamed parameter by not trying
3421                to give the name.  */
3422
3423             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3424               {
3425                 error ("cannot put object with volatile field into register");
3426                 return 0;
3427               }
3428
3429             pedwarn ("address of register variable `%s' requested",
3430                      IDENTIFIER_POINTER (DECL_NAME (x)));
3431           }
3432         put_var_into_stack (x);
3433
3434         /* drops in */
3435       case FUNCTION_DECL:
3436         TREE_ADDRESSABLE (x) = 1;
3437 #if 0  /* poplevel deals with this now.  */
3438         if (DECL_CONTEXT (x) == 0)
3439           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3440 #endif
3441
3442       default:
3443         return 1;
3444     }
3445 }
3446 \f
3447 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3448
3449 tree
3450 build_conditional_expr (ifexp, op1, op2)
3451      tree ifexp, op1, op2;
3452 {
3453   register tree type1;
3454   register tree type2;
3455   register enum tree_code code1;
3456   register enum tree_code code2;
3457   register tree result_type = NULL;
3458   tree orig_op1 = op1, orig_op2 = op2;
3459
3460   ifexp = truthvalue_conversion (default_conversion (ifexp));
3461
3462 #if 0 /* Produces wrong result if within sizeof.  */
3463   /* Don't promote the operands separately if they promote
3464      the same way.  Return the unpromoted type and let the combined
3465      value get promoted if necessary.  */
3466
3467   if (TREE_TYPE (op1) == TREE_TYPE (op2)
3468       && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3469       && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3470       && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3471     {
3472       if (TREE_CODE (ifexp) == INTEGER_CST)
3473         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3474
3475       return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3476     }
3477 #endif
3478
3479   /* Promote both alternatives.  */
3480
3481   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3482     op1 = default_conversion (op1);
3483   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3484     op2 = default_conversion (op2);
3485
3486   if (TREE_CODE (ifexp) == ERROR_MARK
3487       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3488       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3489     return error_mark_node;
3490
3491   type1 = TREE_TYPE (op1);
3492   code1 = TREE_CODE (type1);
3493   type2 = TREE_TYPE (op2);
3494   code2 = TREE_CODE (type2);
3495
3496   /* Quickly detect the usual case where op1 and op2 have the same type
3497      after promotion.  */
3498   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3499     {
3500       if (type1 == type2)
3501         result_type = type1;
3502       else
3503         result_type = TYPE_MAIN_VARIANT (type1);
3504     }
3505   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3506             || code1 == COMPLEX_TYPE)
3507            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3508                || code2 == COMPLEX_TYPE))
3509     {
3510       result_type = common_type (type1, type2);
3511
3512       /* If -Wsign-compare, warn here if type1 and type2 have
3513          different signedness.  We'll promote the signed to unsigned
3514          and later code won't know it used to be different.
3515          Do this check on the original types, so that explicit casts
3516          will be considered, but default promotions won't.  */
3517       if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3518           && !skip_evaluation)
3519         {
3520           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3521           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3522
3523           if (unsigned_op1 ^ unsigned_op2)
3524             {
3525               /* Do not warn if the result type is signed, since the
3526                  signed type will only be chosen if it can represent
3527                  all the values of the unsigned type.  */
3528               if (! TREE_UNSIGNED (result_type))
3529                 /* OK */;
3530               /* Do not warn if the signed quantity is an unsuffixed
3531                  integer literal (or some static constant expression
3532                  involving such literals) and it is non-negative.  */
3533               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3534                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3535                 /* OK */;
3536               else
3537                 warning ("signed and unsigned type in conditional expression");
3538             }
3539         }
3540     }
3541   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3542     {
3543       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3544         pedwarn ("ISO C forbids conditional expr with only one void side");
3545       result_type = void_type_node;
3546     }
3547   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3548     {
3549       if (comp_target_types (type1, type2))
3550         result_type = common_type (type1, type2);
3551       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3552                && TREE_CODE (orig_op1) != NOP_EXPR)
3553         result_type = qualify_type (type2, type1);
3554       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3555                && TREE_CODE (orig_op2) != NOP_EXPR)
3556         result_type = qualify_type (type1, type2);
3557       else if (VOID_TYPE_P (TREE_TYPE (type1)))
3558         {
3559           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3560             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3561           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3562                                                           TREE_TYPE (type2)));
3563         }
3564       else if (VOID_TYPE_P (TREE_TYPE (type2)))
3565         {
3566           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3567             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3568           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3569                                                           TREE_TYPE (type1)));
3570         }
3571       else
3572         {
3573           pedwarn ("pointer type mismatch in conditional expression");
3574           result_type = build_pointer_type (void_type_node);
3575         }
3576     }
3577   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3578     {
3579       if (! integer_zerop (op2))
3580         pedwarn ("pointer/integer type mismatch in conditional expression");
3581       else
3582         {
3583           op2 = null_pointer_node;
3584         }
3585       result_type = type1;
3586     }
3587   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3588     {
3589       if (!integer_zerop (op1))
3590         pedwarn ("pointer/integer type mismatch in conditional expression");
3591       else
3592         {
3593           op1 = null_pointer_node;
3594         }
3595       result_type = type2;
3596     }
3597
3598   if (!result_type)
3599     {
3600       if (flag_cond_mismatch)
3601         result_type = void_type_node;
3602       else
3603         {
3604           error ("type mismatch in conditional expression");
3605           return error_mark_node;
3606         }
3607     }
3608
3609   /* Merge const and volatile flags of the incoming types.  */
3610   result_type
3611     = build_type_variant (result_type,
3612                           TREE_READONLY (op1) || TREE_READONLY (op2),
3613                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3614
3615   if (result_type != TREE_TYPE (op1))
3616     op1 = convert_and_check (result_type, op1);
3617   if (result_type != TREE_TYPE (op2))
3618     op2 = convert_and_check (result_type, op2);
3619
3620   if (TREE_CODE (ifexp) == INTEGER_CST)
3621     return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3622
3623   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3624 }
3625 \f
3626 /* Given a list of expressions, return a compound expression
3627    that performs them all and returns the value of the last of them.  */
3628
3629 tree
3630 build_compound_expr (list)
3631      tree list;
3632 {
3633   return internal_build_compound_expr (list, TRUE);
3634 }
3635
3636 static tree
3637 internal_build_compound_expr (list, first_p)
3638      tree list;
3639      int first_p;
3640 {
3641   register tree rest;
3642
3643   if (TREE_CHAIN (list) == 0)
3644     {
3645       /* Convert arrays to pointers when there really is a comma operator.  */
3646       if (!first_p && TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
3647         TREE_VALUE (list) = default_conversion (TREE_VALUE (list));
3648
3649 #if 0 /* If something inside inhibited lvalueness, we should not override.  */
3650       /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
3651
3652       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3653       if (TREE_CODE (list) == NON_LVALUE_EXPR)
3654         list = TREE_OPERAND (list, 0);
3655 #endif
3656
3657       /* Don't let (0, 0) be null pointer constant.  */
3658       if (!first_p && integer_zerop (TREE_VALUE (list)))
3659         return non_lvalue (TREE_VALUE (list));
3660       return TREE_VALUE (list);
3661     }
3662
3663   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3664
3665   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3666     {
3667       /* The left-hand operand of a comma expression is like an expression
3668          statement: with -W or -Wunused, we should warn if it doesn't have
3669          any side-effects, unless it was explicitly cast to (void).  */
3670       if ((extra_warnings || warn_unused_value)
3671            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3672                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3673         warning ("left-hand operand of comma expression has no effect");
3674
3675       /* When pedantic, a compound expression can be neither an lvalue
3676          nor an integer constant expression.  */
3677       if (! pedantic)
3678         return rest;
3679     }
3680
3681   /* With -Wunused, we should also warn if the left-hand operand does have
3682      side-effects, but computes a value which is not used.  For example, in
3683      `foo() + bar(), baz()' the result of the `+' operator is not used,
3684      so we should issue a warning.  */
3685   else if (warn_unused_value)
3686     warn_if_unused_value (TREE_VALUE (list));
3687
3688   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3689 }
3690
3691 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3692
3693 tree
3694 build_c_cast (type, expr)
3695      register tree type;
3696      tree expr;
3697 {
3698   register tree value = expr;
3699
3700   if (type == error_mark_node || expr == error_mark_node)
3701     return error_mark_node;
3702   type = TYPE_MAIN_VARIANT (type);
3703
3704 #if 0
3705   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3706   if (TREE_CODE (value) == NON_LVALUE_EXPR)
3707     value = TREE_OPERAND (value, 0);
3708 #endif
3709
3710   if (TREE_CODE (type) == ARRAY_TYPE)
3711     {
3712       error ("cast specifies array type");
3713       return error_mark_node;
3714     }
3715
3716   if (TREE_CODE (type) == FUNCTION_TYPE)
3717     {
3718       error ("cast specifies function type");
3719       return error_mark_node;
3720     }
3721
3722   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3723     {
3724       if (pedantic)
3725         {
3726           if (TREE_CODE (type) == RECORD_TYPE
3727               || TREE_CODE (type) == UNION_TYPE)
3728             pedwarn ("ISO C forbids casting nonscalar to the same type");
3729         }
3730     }
3731   else if (TREE_CODE (type) == UNION_TYPE)
3732     {
3733       tree field;
3734       if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3735           || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3736         value = default_conversion (value);
3737
3738       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3739         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3740                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3741           break;
3742
3743       if (field)
3744         {
3745           const char *name;
3746           tree t;
3747
3748           if (pedantic)
3749             pedwarn ("ISO C forbids casts to union type");
3750           if (TYPE_NAME (type) != 0)
3751             {
3752               if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3753                 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3754               else
3755                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3756             }
3757           else
3758             name = "";
3759           t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3760                                         build_tree_list (field, value)),
3761                            0, 0);
3762           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3763           return t;
3764         }
3765       error ("cast to union type from type not present in union");
3766       return error_mark_node;
3767     }
3768   else
3769     {
3770       tree otype, ovalue;
3771
3772       /* If casting to void, avoid the error that would come
3773          from default_conversion in the case of a non-lvalue array.  */
3774       if (type == void_type_node)
3775         return build1 (CONVERT_EXPR, type, value);
3776
3777       /* Convert functions and arrays to pointers,
3778          but don't convert any other types.  */
3779       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3780           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3781         value = default_conversion (value);
3782       otype = TREE_TYPE (value);
3783
3784       /* Optionally warn about potentially worrisome casts.  */
3785
3786       if (warn_cast_qual
3787           && TREE_CODE (type) == POINTER_TYPE
3788           && TREE_CODE (otype) == POINTER_TYPE)
3789         {
3790           tree in_type = type;
3791           tree in_otype = otype;
3792           int warn = 0;
3793
3794           /* Check that the qualifiers on IN_TYPE are a superset of
3795              the qualifiers of IN_OTYPE.  The outermost level of
3796              POINTER_TYPE nodes is uninteresting and we stop as soon
3797              as we hit a non-POINTER_TYPE node on either type.  */
3798           do
3799             {
3800               in_otype = TREE_TYPE (in_otype);
3801               in_type = TREE_TYPE (in_type);
3802               warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3803             }
3804           while (TREE_CODE (in_type) == POINTER_TYPE
3805                  && TREE_CODE (in_otype) == POINTER_TYPE);
3806
3807           if (warn)
3808             /* There are qualifiers present in IN_OTYPE that are not
3809                present in IN_TYPE.  */
3810             warning ("cast discards qualifiers from pointer target type");
3811         }
3812
3813       /* Warn about possible alignment problems.  */
3814       if (STRICT_ALIGNMENT && warn_cast_align
3815           && TREE_CODE (type) == POINTER_TYPE
3816           && TREE_CODE (otype) == POINTER_TYPE
3817           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3818           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3819           /* Don't warn about opaque types, where the actual alignment
3820              restriction is unknown.  */
3821           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3822                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3823                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3824           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3825         warning ("cast increases required alignment of target type");
3826
3827       if (TREE_CODE (type) == INTEGER_TYPE
3828           && TREE_CODE (otype) == POINTER_TYPE
3829           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3830           && !TREE_CONSTANT (value))
3831         warning ("cast from pointer to integer of different size");
3832
3833       if (warn_bad_function_cast
3834           && TREE_CODE (value) == CALL_EXPR
3835           && TREE_CODE (type) != TREE_CODE (otype))
3836         warning ("cast does not match function type");
3837
3838       if (TREE_CODE (type) == POINTER_TYPE
3839           && TREE_CODE (otype) == INTEGER_TYPE
3840           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3841           /* Don't warn about converting any constant.  */
3842           && !TREE_CONSTANT (value))
3843         warning ("cast to pointer from integer of different size");
3844
3845       ovalue = value;
3846       value = convert (type, value);
3847
3848       /* Ignore any integer overflow caused by the cast.  */
3849       if (TREE_CODE (value) == INTEGER_CST)
3850         {
3851           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3852           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3853         }
3854     }
3855
3856   /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant.  */
3857   if (pedantic && TREE_CODE (value) == INTEGER_CST
3858       && TREE_CODE (expr) == INTEGER_CST
3859       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3860     value = non_lvalue (value);
3861
3862   /* If pedantic, don't let a cast be an lvalue.  */
3863   if (value == expr && pedantic)
3864     value = non_lvalue (value);
3865
3866   return value;
3867 }
3868
3869 /* Interpret a cast of expression EXPR to type TYPE.  */
3870 tree
3871 c_cast_expr (type, expr)
3872      tree type, expr;
3873 {
3874   int saved_wsp = warn_strict_prototypes;
3875
3876   /* This avoids warnings about unprototyped casts on
3877      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3878   if (TREE_CODE (expr) == INTEGER_CST)
3879     warn_strict_prototypes = 0;
3880   type = groktypename (type);
3881   warn_strict_prototypes = saved_wsp;
3882
3883   return build_c_cast (type, expr);
3884 }
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 a simple asm-statement, from one string literal.  */
6790 tree
6791 simple_asm_stmt (expr)
6792      tree expr;
6793 {
6794   STRIP_NOPS (expr);
6795
6796   if (TREE_CODE (expr) == ADDR_EXPR)
6797     expr = TREE_OPERAND (expr, 0);
6798
6799   if (TREE_CODE (expr) == STRING_CST)
6800     {
6801       tree stmt;
6802
6803       if (TREE_CHAIN (expr))
6804         expr = combine_strings (expr);
6805       stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6806                                    NULL_TREE, NULL_TREE,
6807                                    NULL_TREE));
6808       ASM_INPUT_P (stmt) = 1;
6809       return stmt;
6810     }
6811
6812   error ("argument of `asm' is not a constant string");
6813   return NULL_TREE;
6814 }
6815
6816 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6817    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6818
6819 tree
6820 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6821      tree cv_qualifier;
6822      tree string;
6823      tree outputs;
6824      tree inputs;
6825      tree clobbers;
6826 {
6827   tree tail;
6828
6829   if (TREE_CHAIN (string))
6830     string = combine_strings (string);
6831   if (TREE_CODE (string) != STRING_CST)
6832     {
6833       error ("asm template is not a string constant");
6834       return NULL_TREE;
6835     }
6836
6837   if (cv_qualifier != NULL_TREE
6838       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6839     {
6840       warning ("%s qualifier ignored on asm",
6841                IDENTIFIER_POINTER (cv_qualifier));
6842       cv_qualifier = NULL_TREE;
6843     }
6844
6845   /* We can remove output conversions that change the type,
6846      but not the mode.  */
6847   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6848     {
6849       tree output = TREE_VALUE (tail);
6850
6851       STRIP_NOPS (output);
6852       TREE_VALUE (tail) = output;
6853
6854       /* Allow conversions as LHS here.  build_modify_expr as called below
6855          will do the right thing with them.  */
6856       while (TREE_CODE (output) == NOP_EXPR
6857              || TREE_CODE (output) == CONVERT_EXPR
6858              || TREE_CODE (output) == FLOAT_EXPR
6859              || TREE_CODE (output) == FIX_TRUNC_EXPR
6860              || TREE_CODE (output) == FIX_FLOOR_EXPR
6861              || TREE_CODE (output) == FIX_ROUND_EXPR
6862              || TREE_CODE (output) == FIX_CEIL_EXPR)
6863         output = TREE_OPERAND (output, 0);
6864
6865       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6866     }
6867
6868   /* Remove output conversions that change the type but not the mode.  */
6869   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6870     {
6871       tree output = TREE_VALUE (tail);
6872       STRIP_NOPS (output);
6873       TREE_VALUE (tail) = output;
6874     }
6875
6876   /* Perform default conversions on array and function inputs.
6877      Don't do this for other types as it would screw up operands
6878      expected to be in memory.  */
6879   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6880     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6881         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6882       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6883
6884   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6885                                outputs, inputs, clobbers));
6886 }
6887
6888 /* Expand an ASM statement with operands, handling output operands
6889    that are not variables or INDIRECT_REFS by transforming such
6890    cases into cases that expand_asm_operands can handle.
6891
6892    Arguments are same as for expand_asm_operands.  */
6893
6894 void
6895 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6896      tree string, outputs, inputs, clobbers;
6897      int vol;
6898      const char *filename;
6899      int line;
6900 {
6901   int noutputs = list_length (outputs);
6902   register int i;
6903   /* o[I] is the place that output number I should be written.  */
6904   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6905   register tree tail;
6906
6907   /* Record the contents of OUTPUTS before it is modified.  */
6908   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6909     o[i] = TREE_VALUE (tail);
6910
6911   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6912      OUTPUTS some trees for where the values were actually stored.  */
6913   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6914
6915   /* Copy all the intermediate outputs into the specified outputs.  */
6916   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6917     {
6918       if (o[i] != TREE_VALUE (tail))
6919         {
6920           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6921                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6922           free_temp_slots ();
6923
6924           /* Restore the original value so that it's correct the next
6925              time we expand this function.  */
6926           TREE_VALUE (tail) = o[i];
6927         }
6928       /* Detect modification of read-only values.
6929          (Otherwise done by build_modify_expr.)  */
6930       else
6931         {
6932           tree type = TREE_TYPE (o[i]);
6933           if (TREE_READONLY (o[i])
6934               || TYPE_READONLY (type)
6935               || ((TREE_CODE (type) == RECORD_TYPE
6936                    || TREE_CODE (type) == UNION_TYPE)
6937                   && C_TYPE_FIELDS_READONLY (type)))
6938             readonly_warning (o[i], "modification by `asm'");
6939         }
6940     }
6941
6942   /* Those MODIFY_EXPRs could do autoincrements.  */
6943   emit_queue ();
6944 }
6945 \f
6946 /* Expand a C `return' statement.
6947    RETVAL is the expression for what to return,
6948    or a null pointer for `return;' with no value.  */
6949
6950 tree
6951 c_expand_return (retval)
6952      tree retval;
6953 {
6954   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6955
6956   if (TREE_THIS_VOLATILE (current_function_decl))
6957     warning ("function declared `noreturn' has a `return' statement");
6958
6959   if (!retval)
6960     {
6961       current_function_returns_null = 1;
6962       if ((warn_return_type || flag_isoc99)
6963           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6964         pedwarn_c99 ("`return' with no value, in function returning non-void");
6965     }
6966   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6967     {
6968       current_function_returns_null = 1;
6969       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6970         pedwarn ("`return' with a value, in function returning void");
6971     }
6972   else
6973     {
6974       tree t = convert_for_assignment (valtype, retval, _("return"),
6975                                        NULL_TREE, NULL_TREE, 0);
6976       tree res = DECL_RESULT (current_function_decl);
6977       tree inner;
6978
6979       if (t == error_mark_node)
6980         return NULL_TREE;
6981
6982       inner = t = convert (TREE_TYPE (res), t);
6983
6984       /* Strip any conversions, additions, and subtractions, and see if
6985          we are returning the address of a local variable.  Warn if so.  */
6986       while (1)
6987         {
6988           switch (TREE_CODE (inner))
6989             {
6990             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6991             case PLUS_EXPR:
6992               inner = TREE_OPERAND (inner, 0);
6993               continue;
6994
6995             case MINUS_EXPR:
6996               /* If the second operand of the MINUS_EXPR has a pointer
6997                  type (or is converted from it), this may be valid, so
6998                  don't give a warning.  */
6999               {
7000                 tree op1 = TREE_OPERAND (inner, 1);
7001
7002                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
7003                        && (TREE_CODE (op1) == NOP_EXPR
7004                            || TREE_CODE (op1) == NON_LVALUE_EXPR
7005                            || TREE_CODE (op1) == CONVERT_EXPR))
7006                   op1 = TREE_OPERAND (op1, 0);
7007
7008                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7009                   break;
7010
7011                 inner = TREE_OPERAND (inner, 0);
7012                 continue;
7013               }
7014
7015             case ADDR_EXPR:
7016               inner = TREE_OPERAND (inner, 0);
7017
7018               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
7019                 inner = TREE_OPERAND (inner, 0);
7020
7021               if (TREE_CODE (inner) == VAR_DECL
7022                   && ! DECL_EXTERNAL (inner)
7023                   && ! TREE_STATIC (inner)
7024                   && DECL_CONTEXT (inner) == current_function_decl)
7025                 warning ("function returns address of local variable");
7026               break;
7027
7028             default:
7029               break;
7030             }
7031
7032           break;
7033         }
7034
7035       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
7036       current_function_returns_value = 1;
7037     }
7038
7039  return add_stmt (build_return_stmt (retval));
7040 }
7041 \f
7042 struct c_switch {
7043   /* The SWITCH_STMT being built.  */
7044   tree switch_stmt;
7045   /* A splay-tree mapping the low element of a case range to the high
7046      element, or NULL_TREE if there is no high element.  Used to
7047      determine whether or not a new case label duplicates an old case
7048      label.  We need a tree, rather than simply a hash table, because
7049      of the GNU case range extension.  */
7050   splay_tree cases;
7051   /* The next node on the stack.  */
7052   struct c_switch *next;
7053 };
7054
7055 /* A stack of the currently active switch statements.  The innermost
7056    switch statement is on the top of the stack.  There is no need to
7057    mark the stack for garbage collection because it is only active
7058    during the processing of the body of a function, and we never
7059    collect at that point.  */
7060
7061 static struct c_switch *switch_stack;
7062
7063 /* Start a C switch statement, testing expression EXP.  Return the new
7064    SWITCH_STMT.  */
7065
7066 tree
7067 c_start_case (exp)
7068      tree exp;
7069 {
7070   register enum tree_code code;
7071   tree type;
7072   struct c_switch *cs;
7073
7074   if (exp != error_mark_node)
7075     {
7076       code = TREE_CODE (TREE_TYPE (exp));
7077       type = TREE_TYPE (exp);
7078
7079       if (code != INTEGER_TYPE
7080           && code != ENUMERAL_TYPE
7081           && code != ERROR_MARK)
7082         {
7083           error ("switch quantity not an integer");
7084           exp = integer_zero_node;
7085         }
7086       else
7087         {
7088           tree index;
7089           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7090
7091           if (warn_traditional && !in_system_header
7092               && (type == long_integer_type_node
7093                   || type == long_unsigned_type_node))
7094             warning ("`long' switch expression not converted to `int' in ISO C");
7095
7096           exp = default_conversion (exp);
7097           type = TREE_TYPE (exp);
7098           index = get_unwidened (exp, NULL_TREE);
7099           /* We can't strip a conversion from a signed type to an
7100              unsigned, because if we did, int_fits_type_p would do the
7101              wrong thing when checking case values for being in range,
7102              and it's too hard to do the right thing.  */
7103           if (TREE_UNSIGNED (TREE_TYPE (exp))
7104               == TREE_UNSIGNED (TREE_TYPE (index)))
7105             exp = index;
7106         }
7107     }
7108
7109   /* Add this new SWITCH_STMT to the stack.  */
7110   cs = (struct c_switch *) xmalloc (sizeof (*cs));
7111   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7112   cs->cases = splay_tree_new (case_compare, NULL, NULL);
7113   cs->next = switch_stack;
7114   switch_stack = cs;
7115
7116   return add_stmt (switch_stack->switch_stmt);
7117 }
7118
7119 /* Process a case label.  */
7120
7121 tree
7122 do_case (low_value, high_value)
7123      tree low_value;
7124      tree high_value;
7125 {
7126   tree label = NULL_TREE;
7127
7128   if (switch_stack)
7129     {
7130       label = c_add_case_label (switch_stack->cases,
7131                                 SWITCH_COND (switch_stack->switch_stmt),
7132                                 low_value, high_value);
7133       if (label == error_mark_node)
7134         label = NULL_TREE;
7135     }
7136   else if (low_value)
7137     error ("case label not within a switch statement");
7138   else
7139     error ("`default' label not within a switch statement");
7140
7141   return label;
7142 }
7143
7144 /* Finish the switch statement.  */
7145
7146 void
7147 c_finish_case ()
7148 {
7149   struct c_switch *cs = switch_stack;
7150
7151   RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7152
7153   /* Pop the stack.  */
7154   switch_stack = switch_stack->next;
7155   splay_tree_delete (cs->cases);
7156   free (cs);
7157 }