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