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