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