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