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