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           /* Don't warn about converting any constant.  */
3706           && !TREE_CONSTANT (value))
3707         warning ("cast to pointer from integer of different size");
3708
3709       ovalue = value;
3710       value = convert (type, value);
3711
3712       /* Ignore any integer overflow caused by the cast.  */
3713       if (TREE_CODE (value) == INTEGER_CST)
3714         {
3715           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3716           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3717         }
3718     }
3719
3720   /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant.  */
3721   if (pedantic && TREE_CODE (value) == INTEGER_CST
3722       && TREE_CODE (expr) == INTEGER_CST
3723       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3724     value = non_lvalue (value);
3725
3726   /* If pedantic, don't let a cast be an lvalue.  */
3727   if (value == expr && pedantic)
3728     value = non_lvalue (value);
3729
3730   return value;
3731 }
3732 \f
3733 /* Build an assignment expression of lvalue LHS from value RHS.
3734    MODIFYCODE is the code for a binary operator that we use
3735    to combine the old value of LHS with RHS to get the new value.
3736    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3737
3738 tree
3739 build_modify_expr (lhs, modifycode, rhs)
3740      tree lhs, rhs;
3741      enum tree_code modifycode;
3742 {
3743   register tree result;
3744   tree newrhs;
3745   tree lhstype = TREE_TYPE (lhs);
3746   tree olhstype = lhstype;
3747
3748   /* Types that aren't fully specified cannot be used in assignments.  */
3749   lhs = require_complete_type (lhs);
3750
3751   /* Avoid duplicate error messages from operands that had errors.  */
3752   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3753     return error_mark_node;
3754
3755   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3756   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3757      whose value is 0 to count as a null pointer constant.  */
3758   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3759     rhs = TREE_OPERAND (rhs, 0);
3760
3761   newrhs = rhs;
3762
3763   /* Handle control structure constructs used as "lvalues".  */
3764
3765   switch (TREE_CODE (lhs))
3766     {
3767       /* Handle (a, b) used as an "lvalue".  */
3768     case COMPOUND_EXPR:
3769       pedantic_lvalue_warning (COMPOUND_EXPR);
3770       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3771       if (TREE_CODE (newrhs) == ERROR_MARK)
3772         return error_mark_node;
3773       return build (COMPOUND_EXPR, lhstype,
3774                     TREE_OPERAND (lhs, 0), newrhs);
3775
3776       /* Handle (a ? b : c) used as an "lvalue".  */
3777     case COND_EXPR:
3778       pedantic_lvalue_warning (COND_EXPR);
3779       rhs = save_expr (rhs);
3780       {
3781         /* Produce (a ? (b = rhs) : (c = rhs))
3782            except that the RHS goes through a save-expr
3783            so the code to compute it is only emitted once.  */
3784         tree cond
3785           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3786                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3787                                                        modifycode, rhs),
3788                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3789                                                        modifycode, rhs));
3790         if (TREE_CODE (cond) == ERROR_MARK)
3791           return cond;
3792         /* Make sure the code to compute the rhs comes out
3793            before the split.  */
3794         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3795                       /* But cast it to void to avoid an "unused" error.  */
3796                       convert (void_type_node, rhs), cond);
3797       }
3798     default:
3799       break;
3800     }
3801
3802   /* If a binary op has been requested, combine the old LHS value with the RHS
3803      producing the value we should actually store into the LHS.  */
3804
3805   if (modifycode != NOP_EXPR)
3806     {
3807       lhs = stabilize_reference (lhs);
3808       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3809     }
3810
3811   /* Handle a cast used as an "lvalue".
3812      We have already performed any binary operator using the value as cast.
3813      Now convert the result to the cast type of the lhs,
3814      and then true type of the lhs and store it there;
3815      then convert result back to the cast type to be the value
3816      of the assignment.  */
3817
3818   switch (TREE_CODE (lhs))
3819     {
3820     case NOP_EXPR:
3821     case CONVERT_EXPR:
3822     case FLOAT_EXPR:
3823     case FIX_TRUNC_EXPR:
3824     case FIX_FLOOR_EXPR:
3825     case FIX_ROUND_EXPR:
3826     case FIX_CEIL_EXPR:
3827       if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3828           || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3829         newrhs = default_conversion (newrhs);
3830       {
3831         tree inner_lhs = TREE_OPERAND (lhs, 0);
3832         tree result;
3833         result = build_modify_expr (inner_lhs, NOP_EXPR,
3834                                     convert (TREE_TYPE (inner_lhs),
3835                                              convert (lhstype, newrhs)));
3836         if (TREE_CODE (result) == ERROR_MARK)
3837           return result;
3838         pedantic_lvalue_warning (CONVERT_EXPR);
3839         return convert (TREE_TYPE (lhs), result);
3840       }
3841
3842     default:
3843       break;
3844     }
3845
3846   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3847      Reject anything strange now.  */
3848
3849   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3850     return error_mark_node;
3851
3852   /* Warn about storing in something that is `const'.  */
3853
3854   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3855       || ((TREE_CODE (lhstype) == RECORD_TYPE
3856            || TREE_CODE (lhstype) == UNION_TYPE)
3857           && C_TYPE_FIELDS_READONLY (lhstype)))
3858     readonly_warning (lhs, "assignment");
3859
3860   /* If storing into a structure or union member,
3861      it has probably been given type `int'.
3862      Compute the type that would go with
3863      the actual amount of storage the member occupies.  */
3864
3865   if (TREE_CODE (lhs) == COMPONENT_REF
3866       && (TREE_CODE (lhstype) == INTEGER_TYPE
3867           || TREE_CODE (lhstype) == REAL_TYPE
3868           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3869     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3870
3871   /* If storing in a field that is in actuality a short or narrower than one,
3872      we must store in the field in its actual type.  */
3873
3874   if (lhstype != TREE_TYPE (lhs))
3875     {
3876       lhs = copy_node (lhs);
3877       TREE_TYPE (lhs) = lhstype;
3878     }
3879
3880   /* Convert new value to destination type.  */
3881
3882   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3883                                    NULL_TREE, NULL_TREE, 0);
3884   if (TREE_CODE (newrhs) == ERROR_MARK)
3885     return error_mark_node;
3886
3887   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3888   TREE_SIDE_EFFECTS (result) = 1;
3889
3890   /* If we got the LHS in a different type for storing in,
3891      convert the result back to the nominal type of LHS
3892      so that the value we return always has the same type
3893      as the LHS argument.  */
3894
3895   if (olhstype == TREE_TYPE (result))
3896     return result;
3897   return convert_for_assignment (olhstype, result, _("assignment"),
3898                                  NULL_TREE, NULL_TREE, 0);
3899 }
3900 \f
3901 /* Convert value RHS to type TYPE as preparation for an assignment
3902    to an lvalue of type TYPE.
3903    The real work of conversion is done by `convert'.
3904    The purpose of this function is to generate error messages
3905    for assignments that are not allowed in C.
3906    ERRTYPE is a string to use in error messages:
3907    "assignment", "return", etc.  If it is null, this is parameter passing
3908    for a function call (and different error messages are output).
3909
3910    FUNNAME is the name of the function being called,
3911    as an IDENTIFIER_NODE, or null.
3912    PARMNUM is the number of the argument, for printing in error messages.  */
3913
3914 static tree
3915 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
3916      tree type, rhs;
3917      const char *errtype;
3918      tree fundecl, funname;
3919      int parmnum;
3920 {
3921   register enum tree_code codel = TREE_CODE (type);
3922   register tree rhstype;
3923   register enum tree_code coder;
3924
3925   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3926   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3927      whose value is 0 to count as a null pointer constant.  */
3928   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3929     rhs = TREE_OPERAND (rhs, 0);
3930
3931   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3932       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3933     rhs = default_conversion (rhs);
3934   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3935     rhs = decl_constant_value (rhs);
3936
3937   rhstype = TREE_TYPE (rhs);
3938   coder = TREE_CODE (rhstype);
3939
3940   if (coder == ERROR_MARK)
3941     return error_mark_node;
3942
3943   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3944     {
3945       overflow_warning (rhs);
3946       /* Check for Objective-C protocols.  This will issue a warning if
3947          there are protocol violations.  No need to use the return value.  */
3948       maybe_objc_comptypes (type, rhstype, 0);
3949       return rhs;
3950     }
3951
3952   if (coder == VOID_TYPE)
3953     {
3954       error ("void value not ignored as it ought to be");
3955       return error_mark_node;
3956     }
3957   /* A type converts to a reference to it.
3958      This code doesn't fully support references, it's just for the
3959      special case of va_start and va_copy.  */
3960   if (codel == REFERENCE_TYPE
3961       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3962     {
3963       if (mark_addressable (rhs) == 0)
3964         return error_mark_node;
3965       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3966
3967       /* We already know that these two types are compatible, but they
3968          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3969          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3970          likely to be va_list, a typedef to __builtin_va_list, which
3971          is different enough that it will cause problems later.  */
3972       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3973         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3974
3975       rhs = build1 (NOP_EXPR, type, rhs);
3976       return rhs;
3977     }
3978   /* Arithmetic types all interconvert, and enum is treated like int.  */
3979   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3980             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE)
3981            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3982                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE))
3983     return convert_and_check (type, rhs);
3984
3985   /* Conversion to a transparent union from its member types.
3986      This applies only to function arguments.  */
3987   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
3988     {
3989       tree memb_types;
3990       tree marginal_memb_type = 0;
3991
3992       for (memb_types = TYPE_FIELDS (type); memb_types;
3993            memb_types = TREE_CHAIN (memb_types))
3994         {
3995           tree memb_type = TREE_TYPE (memb_types);
3996
3997           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3998                          TYPE_MAIN_VARIANT (rhstype)))
3999             break;
4000
4001           if (TREE_CODE (memb_type) != POINTER_TYPE)
4002             continue;
4003
4004           if (coder == POINTER_TYPE)
4005             {
4006               register tree ttl = TREE_TYPE (memb_type);
4007               register tree ttr = TREE_TYPE (rhstype);
4008
4009               /* Any non-function converts to a [const][volatile] void *
4010                  and vice versa; otherwise, targets must be the same.
4011                  Meanwhile, the lhs target must have all the qualifiers of
4012                  the rhs.  */
4013               if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4014                   || TYPE_MAIN_VARIANT (ttr) == void_type_node
4015                   || comp_target_types (memb_type, rhstype))
4016                 {
4017                   /* If this type won't generate any warnings, use it.  */
4018                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4019                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4020                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4021                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4022                              == TYPE_QUALS (ttr))
4023                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4024                              == TYPE_QUALS (ttl))))
4025                     break;
4026
4027                   /* Keep looking for a better type, but remember this one.  */
4028                   if (! marginal_memb_type)
4029                     marginal_memb_type = memb_type;
4030                 }
4031             }
4032
4033           /* Can convert integer zero to any pointer type.  */
4034           if (integer_zerop (rhs)
4035               || (TREE_CODE (rhs) == NOP_EXPR
4036                   && integer_zerop (TREE_OPERAND (rhs, 0))))
4037             {
4038               rhs = null_pointer_node;
4039               break;
4040             }
4041         }
4042
4043       if (memb_types || marginal_memb_type)
4044         {
4045           if (! memb_types)
4046             {
4047               /* We have only a marginally acceptable member type;
4048                  it needs a warning.  */
4049               register tree ttl = TREE_TYPE (marginal_memb_type);
4050               register tree ttr = TREE_TYPE (rhstype);
4051
4052               /* Const and volatile mean something different for function
4053                  types, so the usual warnings are not appropriate.  */
4054               if (TREE_CODE (ttr) == FUNCTION_TYPE
4055                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4056                 {
4057                   /* Because const and volatile on functions are
4058                      restrictions that say the function will not do
4059                      certain things, it is okay to use a const or volatile
4060                      function where an ordinary one is wanted, but not
4061                      vice-versa.  */
4062                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4063                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
4064                                          errtype, funname, parmnum);
4065                 }
4066               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4067                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4068                                      errtype, funname,
4069                                      parmnum);
4070             }
4071
4072           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4073             pedwarn ("ANSI C prohibits argument conversion to union type");
4074
4075           return build1 (NOP_EXPR, type, rhs);
4076         }
4077     }
4078
4079   /* Conversions among pointers */
4080   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4081            && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4082     {
4083       register tree ttl = TREE_TYPE (type);
4084       register tree ttr = TREE_TYPE (rhstype);
4085
4086       /* Any non-function converts to a [const][volatile] void *
4087          and vice versa; otherwise, targets must be the same.
4088          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4089       if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4090           || TYPE_MAIN_VARIANT (ttr) == void_type_node
4091           || comp_target_types (type, rhstype)
4092           || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4093               == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4094         {
4095           if (pedantic
4096               && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
4097                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4098                   ||
4099                   (TYPE_MAIN_VARIANT (ttr) == void_type_node
4100                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
4101                       which are not ANSI null ptr constants.  */
4102                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4103                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4104             warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
4105                                  errtype, funname, parmnum);
4106           /* Const and volatile mean something different for function types,
4107              so the usual warnings are not appropriate.  */
4108           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4109                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4110             {
4111               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4112                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4113                                      errtype, funname, parmnum);
4114               /* If this is not a case of ignoring a mismatch in signedness,
4115                  no warning.  */
4116               else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4117                        || TYPE_MAIN_VARIANT (ttr) == void_type_node
4118                        || comp_target_types (type, rhstype))
4119                 ;
4120               /* If there is a mismatch, do warn.  */
4121               else if (pedantic)
4122                 warn_for_assignment ("pointer targets in %s differ in signedness",
4123                                      errtype, funname, parmnum);
4124             }
4125           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4126                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4127             {
4128               /* Because const and volatile on functions are restrictions
4129                  that say the function will not do certain things,
4130                  it is okay to use a const or volatile function
4131                  where an ordinary one is wanted, but not vice-versa.  */
4132               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4133                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4134                                      errtype, funname, parmnum);
4135             }
4136         }
4137       else
4138         warn_for_assignment ("%s from incompatible pointer type",
4139                              errtype, funname, parmnum);
4140       return convert (type, rhs);
4141     }
4142   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4143     {
4144       /* An explicit constant 0 can convert to a pointer,
4145          or one that results from arithmetic, even including
4146          a cast to integer type.  */
4147       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4148           &&
4149           ! (TREE_CODE (rhs) == NOP_EXPR
4150              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4151              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4152              && integer_zerop (TREE_OPERAND (rhs, 0))))
4153         {
4154           warn_for_assignment ("%s makes pointer from integer without a cast",
4155                                errtype, funname, parmnum);
4156           return convert (type, rhs);
4157         }
4158       return null_pointer_node;
4159     }
4160   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4161     {
4162       warn_for_assignment ("%s makes integer from pointer without a cast",
4163                            errtype, funname, parmnum);
4164       return convert (type, rhs);
4165     }
4166
4167   if (!errtype)
4168     {
4169       if (funname)
4170         {
4171           tree selector = maybe_building_objc_message_expr ();
4172
4173           if (selector && parmnum > 2)
4174             error ("incompatible type for argument %d of `%s'",
4175                    parmnum - 2, IDENTIFIER_POINTER (selector));
4176           else
4177             error ("incompatible type for argument %d of `%s'",
4178                    parmnum, IDENTIFIER_POINTER (funname));
4179         }
4180       else
4181         error ("incompatible type for argument %d of indirect function call",
4182                parmnum);
4183     }
4184   else
4185     error ("incompatible types in %s", errtype);
4186
4187   return error_mark_node;
4188 }
4189
4190 /* Print a warning using MSGID.
4191    It gets OPNAME as its one parameter.
4192    If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4193    FUNCTION and ARGNUM are handled specially if we are building an
4194    Objective-C selector.  */
4195
4196 static void
4197 warn_for_assignment (msgid, opname, function, argnum)
4198      const char *msgid;
4199      const char *opname;
4200      tree function;
4201      int argnum;
4202 {
4203   if (opname == 0)
4204     {
4205       tree selector = maybe_building_objc_message_expr ();
4206       char * new_opname;
4207
4208       if (selector && argnum > 2)
4209         {
4210           function = selector;
4211           argnum -= 2;
4212         }
4213       if (function)
4214         {
4215           /* Function name is known; supply it.  */
4216           const char *argstring = _("passing arg %d of `%s'");
4217           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4218                                         + strlen (argstring) + 1 + 25
4219                                         /*%d*/ + 1);
4220           sprintf (new_opname, argstring, argnum,
4221                    IDENTIFIER_POINTER (function));
4222         }
4223       else
4224         {
4225           /* Function name unknown (call through ptr); just give arg number.*/
4226           const char *argnofun = _("passing arg %d of pointer to function");
4227           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4228           sprintf (new_opname, argnofun, argnum);
4229         }
4230       opname = new_opname;
4231     }
4232   pedwarn (msgid, opname);
4233 }
4234 \f
4235 /* If VALUE is a compound expr all of whose expressions are constant, then
4236    return its value.  Otherwise, return error_mark_node.
4237
4238    This is for handling COMPOUND_EXPRs as initializer elements
4239    which is allowed with a warning when -pedantic is specified.  */
4240
4241 static tree
4242 valid_compound_expr_initializer (value, endtype)
4243      tree value;
4244      tree endtype;
4245 {
4246   if (TREE_CODE (value) == COMPOUND_EXPR)
4247     {
4248       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4249           == error_mark_node)
4250         return error_mark_node;
4251       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4252                                               endtype);
4253     }
4254   else if (! TREE_CONSTANT (value)
4255            && ! initializer_constant_valid_p (value, endtype))
4256     return error_mark_node;
4257   else
4258     return value;
4259 }
4260 \f
4261 /* Perform appropriate conversions on the initial value of a variable,
4262    store it in the declaration DECL,
4263    and print any error messages that are appropriate.
4264    If the init is invalid, store an ERROR_MARK.  */
4265
4266 void
4267 store_init_value (decl, init)
4268      tree decl, init;
4269 {
4270   register tree value, type;
4271
4272   /* If variable's type was invalidly declared, just ignore it.  */
4273
4274   type = TREE_TYPE (decl);
4275   if (TREE_CODE (type) == ERROR_MARK)
4276     return;
4277
4278   /* Digest the specified initializer into an expression.  */
4279
4280   value = digest_init (type, init, TREE_STATIC (decl),
4281                        TREE_STATIC (decl) || pedantic);
4282
4283   /* Store the expression if valid; else report error.  */
4284
4285 #if 0
4286   /* Note that this is the only place we can detect the error
4287      in a case such as   struct foo bar = (struct foo) { x, y };
4288      where there is one initial value which is a constructor expression.  */
4289   if (value == error_mark_node)
4290     ;
4291   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4292     {
4293       error ("initializer for static variable is not constant");
4294       value = error_mark_node;
4295     }
4296   else if (TREE_STATIC (decl)
4297            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4298     {
4299       error ("initializer for static variable uses complicated arithmetic");
4300       value = error_mark_node;
4301     }
4302   else
4303     {
4304       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4305         {
4306           if (! TREE_CONSTANT (value))
4307             pedwarn ("aggregate initializer is not constant");
4308           else if (! TREE_STATIC (value))
4309             pedwarn ("aggregate initializer uses complicated arithmetic");
4310         }
4311     }
4312 #endif
4313
4314   DECL_INITIAL (decl) = value;
4315
4316   /* ANSI wants warnings about out-of-range constant initializers.  */
4317   STRIP_TYPE_NOPS (value);
4318   constant_expression_warning (value);
4319 }
4320 \f
4321 /* Methods for storing and printing names for error messages.  */
4322
4323 /* Implement a spelling stack that allows components of a name to be pushed
4324    and popped.  Each element on the stack is this structure.  */
4325
4326 struct spelling
4327 {
4328   int kind;
4329   union
4330     {
4331       int i;
4332       const char *s;
4333     } u;
4334 };
4335
4336 #define SPELLING_STRING 1
4337 #define SPELLING_MEMBER 2
4338 #define SPELLING_BOUNDS 3
4339
4340 static struct spelling *spelling;       /* Next stack element (unused).  */
4341 static struct spelling *spelling_base;  /* Spelling stack base.  */
4342 static int spelling_size;               /* Size of the spelling stack.  */
4343
4344 /* Macros to save and restore the spelling stack around push_... functions.
4345    Alternative to SAVE_SPELLING_STACK.  */
4346
4347 #define SPELLING_DEPTH() (spelling - spelling_base)
4348 #define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4349
4350 /* Save and restore the spelling stack around arbitrary C code.  */
4351
4352 #define SAVE_SPELLING_DEPTH(code)               \
4353 {                                               \
4354   int __depth = SPELLING_DEPTH ();              \
4355   code;                                         \
4356   RESTORE_SPELLING_DEPTH (__depth);             \
4357 }
4358
4359 /* Push an element on the spelling stack with type KIND and assign VALUE
4360    to MEMBER.  */
4361
4362 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4363 {                                                                       \
4364   int depth = SPELLING_DEPTH ();                                        \
4365                                                                         \
4366   if (depth >= spelling_size)                                           \
4367     {                                                                   \
4368       spelling_size += 10;                                              \
4369       if (spelling_base == 0)                                           \
4370         spelling_base                                                   \
4371           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4372       else                                                              \
4373         spelling_base                                                   \
4374           = (struct spelling *) xrealloc (spelling_base,                \
4375                                           spelling_size * sizeof (struct spelling));    \
4376       RESTORE_SPELLING_DEPTH (depth);                                   \
4377     }                                                                   \
4378                                                                         \
4379   spelling->kind = (KIND);                                              \
4380   spelling->MEMBER = (VALUE);                                           \
4381   spelling++;                                                           \
4382 }
4383
4384 /* Push STRING on the stack.  Printed literally.  */
4385
4386 static void
4387 push_string (string)
4388      const char *string;
4389 {
4390   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4391 }
4392
4393 /* Push a member name on the stack.  Printed as '.' STRING.  */
4394
4395 static void
4396 push_member_name (decl)
4397      tree decl;
4398
4399 {
4400   const char *string
4401     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4402   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4403 }
4404
4405 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4406
4407 static void
4408 push_array_bounds (bounds)
4409      int bounds;
4410 {
4411   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4412 }
4413
4414 /* Compute the maximum size in bytes of the printed spelling.  */
4415
4416 static int
4417 spelling_length ()
4418 {
4419   register int size = 0;
4420   register struct spelling *p;
4421
4422   for (p = spelling_base; p < spelling; p++)
4423     {
4424       if (p->kind == SPELLING_BOUNDS)
4425         size += 25;
4426       else
4427         size += strlen (p->u.s) + 1;
4428     }
4429
4430   return size;
4431 }
4432
4433 /* Print the spelling to BUFFER and return it.  */
4434
4435 static char *
4436 print_spelling (buffer)
4437      register char *buffer;
4438 {
4439   register char *d = buffer;
4440   register struct spelling *p;
4441
4442   for (p = spelling_base; p < spelling; p++)
4443     if (p->kind == SPELLING_BOUNDS)
4444       {
4445         sprintf (d, "[%d]", p->u.i);
4446         d += strlen (d);
4447       }
4448     else
4449       {
4450         register const char *s;
4451         if (p->kind == SPELLING_MEMBER)
4452           *d++ = '.';
4453         for (s = p->u.s; (*d = *s++); d++)
4454           ;
4455       }
4456   *d++ = '\0';
4457   return buffer;
4458 }
4459
4460 /* Issue an error message for a bad initializer component.
4461    MSGID identifies the message.
4462    The component name is taken from the spelling stack.  */
4463
4464 void
4465 error_init (msgid)
4466      const char *msgid;
4467 {
4468   char *ofwhat;
4469
4470   error ("%s", msgid);
4471   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4472   if (*ofwhat)
4473     error ("(near initialization for `%s')", ofwhat);
4474 }
4475
4476 /* Issue a pedantic warning for a bad initializer component.
4477    MSGID identifies the message.
4478    The component name is taken from the spelling stack.  */
4479
4480 void
4481 pedwarn_init (msgid)
4482      const char *msgid;
4483 {
4484   char *ofwhat;
4485
4486   pedwarn ("%s", msgid);
4487   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4488   if (*ofwhat)
4489     pedwarn ("(near initialization for `%s')", ofwhat);
4490 }
4491
4492 /* Issue a warning for a bad initializer component.
4493    MSGID identifies the message.
4494    The component name is taken from the spelling stack.  */
4495
4496 static void
4497 warning_init (msgid)
4498      const char *msgid;
4499 {
4500   char *ofwhat;
4501
4502   warning ("%s", msgid);
4503   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4504   if (*ofwhat)
4505     warning ("(near initialization for `%s')", ofwhat);
4506 }
4507 \f
4508 /* Digest the parser output INIT as an initializer for type TYPE.
4509    Return a C expression of type TYPE to represent the initial value.
4510
4511    The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4512    if non-constant initializers or elements are seen.  CONSTRUCTOR_CONSTANT
4513    applies only to elements of constructors.  */
4514
4515 static tree
4516 digest_init (type, init, require_constant, constructor_constant)
4517      tree type, init;
4518      int require_constant, constructor_constant;
4519 {
4520   enum tree_code code = TREE_CODE (type);
4521   tree inside_init = init;
4522
4523   if (type == error_mark_node || init == error_mark_node)
4524     return error_mark_node;
4525
4526   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4527   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4528      whose value is 0 to count as a null pointer constant.  */
4529   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4530     inside_init = TREE_OPERAND (init, 0);
4531
4532   /* Initialization of an array of chars from a string constant
4533      optionally enclosed in braces.  */
4534
4535   if (code == ARRAY_TYPE)
4536     {
4537       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4538       if ((typ1 == char_type_node
4539            || typ1 == signed_char_type_node
4540            || typ1 == unsigned_char_type_node
4541            || typ1 == unsigned_wchar_type_node
4542            || typ1 == signed_wchar_type_node)
4543           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4544         {
4545           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4546                          TYPE_MAIN_VARIANT (type)))
4547             return inside_init;
4548
4549           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4550                != char_type_node)
4551               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4552             {
4553               error_init ("char-array initialized from wide string");
4554               return error_mark_node;
4555             }
4556           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4557                == char_type_node)
4558               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4559             {
4560               error_init ("int-array initialized from non-wide string");
4561               return error_mark_node;
4562             }
4563
4564           TREE_TYPE (inside_init) = type;
4565           if (TYPE_DOMAIN (type) != 0
4566               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4567               /* Subtract 1 (or sizeof (wchar_t))
4568                  because it's ok to ignore the terminating null char
4569                  that is counted in the length of the constant.  */
4570               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4571                                        TREE_STRING_LENGTH (inside_init)
4572                                        - ((TYPE_PRECISION (typ1)
4573                                            != TYPE_PRECISION (char_type_node))
4574                                           ? (TYPE_PRECISION (wchar_type_node)
4575                                              / BITS_PER_UNIT)
4576                                           : 1)))
4577             pedwarn_init ("initializer-string for array of chars is too long");
4578
4579           return inside_init;
4580         }
4581     }
4582
4583   /* Any type can be initialized
4584      from an expression of the same type, optionally with braces.  */
4585
4586   if (inside_init && TREE_TYPE (inside_init) != 0
4587       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4588                      TYPE_MAIN_VARIANT (type))
4589           || (code == ARRAY_TYPE
4590               && comptypes (TREE_TYPE (inside_init), type))
4591           || (code == POINTER_TYPE
4592               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4593                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4594               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4595                             TREE_TYPE (type)))))
4596     {
4597       if (code == POINTER_TYPE
4598           && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4599               || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4600         inside_init = default_conversion (inside_init);
4601       else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4602                && TREE_CODE (inside_init) != CONSTRUCTOR)
4603         {
4604           error_init ("array initialized from non-constant array expression");
4605           return error_mark_node;
4606         }
4607
4608       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4609         inside_init = decl_constant_value (inside_init);
4610
4611       /* Compound expressions can only occur here if -pedantic or
4612          -pedantic-errors is specified.  In the later case, we always want
4613          an error.  In the former case, we simply want a warning.  */
4614       if (require_constant && pedantic
4615           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4616         {
4617           inside_init
4618             = valid_compound_expr_initializer (inside_init,
4619                                                TREE_TYPE (inside_init));
4620           if (inside_init == error_mark_node)
4621             error_init ("initializer element is not constant");
4622           else
4623             pedwarn_init ("initializer element is not constant");
4624           if (flag_pedantic_errors)
4625             inside_init = error_mark_node;
4626         }
4627       else if (require_constant && ! TREE_CONSTANT (inside_init))
4628         {
4629           error_init ("initializer element is not constant");
4630           inside_init = error_mark_node;
4631         }
4632       else if (require_constant
4633                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4634         {
4635           error_init ("initializer element is not computable at load time");
4636           inside_init = error_mark_node;
4637         }
4638
4639       return inside_init;
4640     }
4641
4642   /* Handle scalar types, including conversions.  */
4643
4644   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4645       || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4646     {
4647       /* Note that convert_for_assignment calls default_conversion
4648          for arrays and functions.  We must not call it in the
4649          case where inside_init is a null pointer constant.  */
4650       inside_init
4651         = convert_for_assignment (type, init, _("initialization"),
4652                                   NULL_TREE, NULL_TREE, 0);
4653
4654       if (require_constant && ! TREE_CONSTANT (inside_init))
4655         {
4656           error_init ("initializer element is not constant");
4657           inside_init = error_mark_node;
4658         }
4659       else if (require_constant
4660                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4661         {
4662           error_init ("initializer element is not computable at load time");
4663           inside_init = error_mark_node;
4664         }
4665
4666       return inside_init;
4667     }
4668
4669   /* Come here only for records and arrays.  */
4670
4671   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4672     {
4673       error_init ("variable-sized object may not be initialized");
4674       return error_mark_node;
4675     }
4676
4677   /* Traditionally, you can write  struct foo x = 0;
4678      and it initializes the first element of x to 0.  */
4679   if (flag_traditional)
4680     {
4681       tree top = 0, prev = 0, otype = type;
4682       while (TREE_CODE (type) == RECORD_TYPE
4683              || TREE_CODE (type) == ARRAY_TYPE
4684              || TREE_CODE (type) == QUAL_UNION_TYPE
4685              || TREE_CODE (type) == UNION_TYPE)
4686         {
4687           tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4688           if (prev == 0)
4689             top = temp;
4690           else
4691             TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4692           prev = temp;
4693           if (TREE_CODE (type) == ARRAY_TYPE)
4694             type = TREE_TYPE (type);
4695           else if (TYPE_FIELDS (type))
4696             type = TREE_TYPE (TYPE_FIELDS (type));
4697           else
4698             {
4699               error_init ("invalid initializer");
4700               return error_mark_node;
4701             }
4702         }
4703
4704       if (otype != type)
4705         {
4706           TREE_OPERAND (prev, 1)
4707             = build_tree_list (NULL_TREE,
4708                                digest_init (type, init, require_constant,
4709                                             constructor_constant));
4710           return top;
4711         }
4712       else
4713         return error_mark_node;
4714     }
4715   error_init ("invalid initializer");
4716   return error_mark_node;
4717 }
4718 \f
4719 /* Handle initializers that use braces.  */
4720
4721 /* Type of object we are accumulating a constructor for.
4722    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4723 static tree constructor_type;
4724
4725 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4726    left to fill.  */
4727 static tree constructor_fields;
4728
4729 /* For an ARRAY_TYPE, this is the specified index
4730    at which to store the next element we get.  */
4731 static tree constructor_index;
4732
4733 /* For an ARRAY_TYPE, this is the end index of the range
4734    to initialize with the next element, or NULL in the ordinary case
4735    where the element is used just once.  */
4736 static tree constructor_range_end;
4737
4738 /* For an ARRAY_TYPE, this is the maximum index.  */
4739 static tree constructor_max_index;
4740
4741 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4742 static tree constructor_unfilled_fields;
4743
4744 /* For an ARRAY_TYPE, this is the index of the first element
4745    not yet written out.  */
4746 static tree constructor_unfilled_index;
4747
4748 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4749    This is so we can generate gaps between fields, when appropriate.  */
4750 static tree constructor_bit_index;
4751
4752 /* If we are saving up the elements rather than allocating them,
4753    this is the list of elements so far (in reverse order,
4754    most recent first).  */
4755 static tree constructor_elements;
4756
4757 /* 1 if so far this constructor's elements are all compile-time constants.  */
4758 static int constructor_constant;
4759
4760 /* 1 if so far this constructor's elements are all valid address constants.  */
4761 static int constructor_simple;
4762
4763 /* 1 if this constructor is erroneous so far.  */
4764 static int constructor_erroneous;
4765
4766 /* 1 if have called defer_addressed_constants.  */
4767 static int constructor_subconstants_deferred;
4768
4769 /* Structure for managing pending initializer elements, organized as an
4770    AVL tree.  */
4771
4772 struct init_node
4773 {
4774   struct init_node *left, *right;
4775   struct init_node *parent;
4776   int balance;
4777   tree purpose;
4778   tree value;
4779 };
4780
4781 /* Tree of pending elements at this constructor level.
4782    These are elements encountered out of order
4783    which belong at places we haven't reached yet in actually
4784    writing the output.
4785    Will never hold tree nodes across GC runs.  */
4786 static struct init_node *constructor_pending_elts;
4787
4788 /* The SPELLING_DEPTH of this constructor.  */
4789 static int constructor_depth;
4790
4791 /* 0 if implicitly pushing constructor levels is allowed.  */
4792 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4793
4794 static int require_constant_value;
4795 static int require_constant_elements;
4796
4797 /* 1 if it is ok to output this constructor as we read it.
4798    0 means must accumulate a CONSTRUCTOR expression.  */
4799 static int constructor_incremental;
4800
4801 /* DECL node for which an initializer is being read.
4802    0 means we are reading a constructor expression
4803    such as (struct foo) {...}.  */
4804 static tree constructor_decl;
4805
4806 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4807 static char *constructor_asmspec;
4808
4809 /* Nonzero if this is an initializer for a top-level decl.  */
4810 static int constructor_top_level;
4811
4812 \f
4813 /* This stack has a level for each implicit or explicit level of
4814    structuring in the initializer, including the outermost one.  It
4815    saves the values of most of the variables above.  */
4816
4817 struct constructor_stack
4818 {
4819   struct constructor_stack *next;
4820   tree type;
4821   tree fields;
4822   tree index;
4823   tree range_end;
4824   tree max_index;
4825   tree unfilled_index;
4826   tree unfilled_fields;
4827   tree bit_index;
4828   tree elements;
4829   int offset;
4830   struct init_node *pending_elts;
4831   int depth;
4832   /* If nonzero, this value should replace the entire
4833      constructor at this level.  */
4834   tree replacement_value;
4835   char constant;
4836   char simple;
4837   char implicit;
4838   char incremental;
4839   char erroneous;
4840   char outer;
4841 };
4842
4843 struct constructor_stack *constructor_stack;
4844
4845 /* This stack records separate initializers that are nested.
4846    Nested initializers can't happen in ANSI C, but GNU C allows them
4847    in cases like { ... (struct foo) { ... } ... }.  */
4848
4849 struct initializer_stack
4850 {
4851   struct initializer_stack *next;
4852   tree decl;
4853   char *asmspec;
4854   struct constructor_stack *constructor_stack;
4855   tree elements;
4856   struct spelling *spelling;
4857   struct spelling *spelling_base;
4858   int spelling_size;
4859   char top_level;
4860   char incremental;
4861   char require_constant_value;
4862   char require_constant_elements;
4863   char deferred;
4864 };
4865
4866 struct initializer_stack *initializer_stack;
4867 \f
4868 /* Prepare to parse and output the initializer for variable DECL.  */
4869
4870 void
4871 start_init (decl, asmspec_tree, top_level)
4872      tree decl;
4873      tree asmspec_tree;
4874      int top_level;
4875 {
4876   const char *locus;
4877   struct initializer_stack *p
4878     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
4879   char *asmspec = 0;
4880
4881   if (asmspec_tree)
4882     asmspec = TREE_STRING_POINTER (asmspec_tree);
4883
4884   p->decl = constructor_decl;
4885   p->asmspec = constructor_asmspec;
4886   p->incremental = constructor_incremental;
4887   p->require_constant_value = require_constant_value;
4888   p->require_constant_elements = require_constant_elements;
4889   p->constructor_stack = constructor_stack;
4890   p->elements = constructor_elements;
4891   p->spelling = spelling;
4892   p->spelling_base = spelling_base;
4893   p->spelling_size = spelling_size;
4894   p->deferred = constructor_subconstants_deferred;
4895   p->top_level = constructor_top_level;
4896   p->next = initializer_stack;
4897   initializer_stack = p;
4898
4899   constructor_decl = decl;
4900   constructor_incremental = top_level;
4901   constructor_asmspec = asmspec;
4902   constructor_subconstants_deferred = 0;
4903   constructor_top_level = top_level;
4904
4905   if (decl != 0)
4906     {
4907       require_constant_value = TREE_STATIC (decl);
4908       require_constant_elements
4909         = ((TREE_STATIC (decl) || pedantic)
4910            /* For a scalar, you can always use any value to initialize,
4911               even within braces.  */
4912            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4913                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4914                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4915                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4916       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4917       constructor_incremental |= TREE_STATIC (decl);
4918     }
4919   else
4920     {
4921       require_constant_value = 0;
4922       require_constant_elements = 0;
4923       locus = "(anonymous)";
4924     }
4925
4926   constructor_stack = 0;
4927
4928   missing_braces_mentioned = 0;
4929
4930   spelling_base = 0;
4931   spelling_size = 0;
4932   RESTORE_SPELLING_DEPTH (0);
4933
4934   if (locus)
4935     push_string (locus);
4936 }
4937
4938 void
4939 finish_init ()
4940 {
4941   struct initializer_stack *p = initializer_stack;
4942
4943   /* Output subconstants (string constants, usually)
4944      that were referenced within this initializer and saved up.
4945      Must do this if and only if we called defer_addressed_constants.  */
4946   if (constructor_subconstants_deferred)
4947     output_deferred_addressed_constants ();
4948
4949   /* Free the whole constructor stack of this initializer.  */
4950   while (constructor_stack)
4951     {
4952       struct constructor_stack *q = constructor_stack;
4953       constructor_stack = q->next;
4954       free (q);
4955     }
4956
4957   /* Pop back to the data of the outer initializer (if any).  */
4958   constructor_decl = p->decl;
4959   constructor_asmspec = p->asmspec;
4960   constructor_incremental = p->incremental;
4961   require_constant_value = p->require_constant_value;
4962   require_constant_elements = p->require_constant_elements;
4963   constructor_stack = p->constructor_stack;
4964   constructor_elements = p->elements;
4965   spelling = p->spelling;
4966   spelling_base = p->spelling_base;
4967   spelling_size = p->spelling_size;
4968   constructor_subconstants_deferred = p->deferred;
4969   constructor_top_level = p->top_level;
4970   initializer_stack = p->next;
4971   free (p);
4972 }
4973 \f
4974 /* Call here when we see the initializer is surrounded by braces.
4975    This is instead of a call to push_init_level;
4976    it is matched by a call to pop_init_level.
4977
4978    TYPE is the type to initialize, for a constructor expression.
4979    For an initializer for a decl, TYPE is zero.  */
4980
4981 void
4982 really_start_incremental_init (type)
4983      tree type;
4984 {
4985   struct constructor_stack *p
4986     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
4987
4988   if (type == 0)
4989     type = TREE_TYPE (constructor_decl);
4990
4991   /* Turn off constructor_incremental if type is a struct with bitfields.
4992      Do this before the first push, so that the corrected value
4993      is available in finish_init.  */
4994   check_init_type_bitfields (type);
4995
4996   p->type = constructor_type;
4997   p->fields = constructor_fields;
4998   p->index = constructor_index;
4999   p->range_end = constructor_range_end;
5000   p->max_index = constructor_max_index;
5001   p->unfilled_index = constructor_unfilled_index;
5002   p->unfilled_fields = constructor_unfilled_fields;
5003   p->bit_index = constructor_bit_index;
5004   p->elements = constructor_elements;
5005   p->constant = constructor_constant;
5006   p->simple = constructor_simple;
5007   p->erroneous = constructor_erroneous;
5008   p->pending_elts = constructor_pending_elts;
5009   p->depth = constructor_depth;
5010   p->replacement_value = 0;
5011   p->implicit = 0;
5012   p->incremental = constructor_incremental;
5013   p->outer = 0;
5014   p->next = 0;
5015   constructor_stack = p;
5016
5017   constructor_constant = 1;
5018   constructor_simple = 1;
5019   constructor_depth = SPELLING_DEPTH ();
5020   constructor_elements = 0;
5021   constructor_pending_elts = 0;
5022   constructor_type = type;
5023
5024   if (TREE_CODE (constructor_type) == RECORD_TYPE
5025       || TREE_CODE (constructor_type) == UNION_TYPE)
5026     {
5027       constructor_fields = TYPE_FIELDS (constructor_type);
5028       /* Skip any nameless bit fields at the beginning.  */
5029       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5030              && DECL_NAME (constructor_fields) == 0)
5031         constructor_fields = TREE_CHAIN (constructor_fields);
5032
5033       constructor_unfilled_fields = constructor_fields;
5034       constructor_bit_index = bitsize_zero_node;
5035     }
5036   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5037     {
5038       constructor_range_end = 0;
5039       if (TYPE_DOMAIN (constructor_type))
5040         {
5041           constructor_max_index
5042             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5043           constructor_index
5044             = convert (bitsizetype,
5045                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5046         }
5047       else
5048         constructor_index = bitsize_zero_node;
5049
5050       constructor_unfilled_index = constructor_index;
5051     }
5052   else
5053     {
5054       /* Handle the case of int x = {5}; */
5055       constructor_fields = constructor_type;
5056       constructor_unfilled_fields = constructor_type;
5057     }
5058
5059   if (constructor_incremental)
5060     {
5061       make_decl_rtl (constructor_decl, constructor_asmspec,
5062                      constructor_top_level);
5063       assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5064
5065       defer_addressed_constants ();
5066       constructor_subconstants_deferred = 1;
5067     }
5068 }
5069 \f
5070 /* Push down into a subobject, for initialization.
5071    If this is for an explicit set of braces, IMPLICIT is 0.
5072    If it is because the next element belongs at a lower level,
5073    IMPLICIT is 1.  */
5074
5075 void
5076 push_init_level (implicit)
5077      int implicit;
5078 {
5079   struct constructor_stack *p;
5080
5081   /* If we've exhausted any levels that didn't have braces,
5082      pop them now.  */
5083   while (constructor_stack->implicit)
5084     {
5085       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5086            || TREE_CODE (constructor_type) == UNION_TYPE)
5087           && constructor_fields == 0)
5088         process_init_element (pop_init_level (1));
5089       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5090                && tree_int_cst_lt (constructor_max_index, constructor_index))
5091         process_init_element (pop_init_level (1));
5092       else
5093         break;
5094     }
5095
5096   /* Structure elements may require alignment.  Do this now if necessary
5097      for the subaggregate, and if it comes next in sequence.  Don't do
5098      this for subaggregates that will go on the pending list.  */
5099   if (constructor_incremental && constructor_type != 0
5100       && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
5101       && constructor_fields == constructor_unfilled_fields)
5102     {
5103       /* Advance to offset of this element.  */
5104       if (! tree_int_cst_equal (constructor_bit_index,
5105                                 bit_position (constructor_fields)))
5106         assemble_zeros
5107           (tree_low_cst
5108            (size_binop (TRUNC_DIV_EXPR,
5109                         size_binop (MINUS_EXPR,
5110                                     bit_position (constructor_fields),
5111                                     constructor_bit_index),
5112                         bitsize_unit_node),
5113             1));
5114
5115       /* Indicate that we have now filled the structure up to the current
5116          field.  */
5117       constructor_unfilled_fields = constructor_fields;
5118     }
5119
5120   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5121   p->type = constructor_type;
5122   p->fields = constructor_fields;
5123   p->index = constructor_index;
5124   p->range_end = constructor_range_end;
5125   p->max_index = constructor_max_index;
5126   p->unfilled_index = constructor_unfilled_index;
5127   p->unfilled_fields = constructor_unfilled_fields;
5128   p->bit_index = constructor_bit_index;
5129   p->elements = constructor_elements;
5130   p->constant = constructor_constant;
5131   p->simple = constructor_simple;
5132   p->erroneous = constructor_erroneous;
5133   p->pending_elts = constructor_pending_elts;
5134   p->depth = constructor_depth;
5135   p->replacement_value = 0;
5136   p->implicit = implicit;
5137   p->incremental = constructor_incremental;
5138   p->outer = 0;
5139   p->next = constructor_stack;
5140   constructor_stack = p;
5141
5142   constructor_constant = 1;
5143   constructor_simple = 1;
5144   constructor_depth = SPELLING_DEPTH ();
5145   constructor_elements = 0;
5146   constructor_pending_elts = 0;
5147
5148   /* Don't die if an entire brace-pair level is superfluous
5149      in the containing level.  */
5150   if (constructor_type == 0)
5151     ;
5152   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5153            || TREE_CODE (constructor_type) == UNION_TYPE)
5154     {
5155       /* Don't die if there are extra init elts at the end.  */
5156       if (constructor_fields == 0)
5157         constructor_type = 0;
5158       else
5159         {
5160           constructor_type = TREE_TYPE (constructor_fields);
5161           push_member_name (constructor_fields);
5162           constructor_depth++;
5163           if (constructor_fields != constructor_unfilled_fields)
5164             constructor_incremental = 0;
5165         }
5166     }
5167   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5168     {
5169       constructor_type = TREE_TYPE (constructor_type);
5170       push_array_bounds (tree_low_cst (constructor_index, 0));
5171       constructor_depth++;
5172       if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5173           || constructor_range_end != 0)
5174         constructor_incremental = 0;
5175     }
5176
5177   if (constructor_type == 0)
5178     {
5179       error_init ("extra brace group at end of initializer");
5180       constructor_fields = 0;
5181       constructor_unfilled_fields = 0;
5182       return;
5183     }
5184
5185   /* Turn off constructor_incremental if type is a struct with bitfields.  */
5186   check_init_type_bitfields (constructor_type);
5187
5188   if (implicit && warn_missing_braces && !missing_braces_mentioned)
5189     {
5190       missing_braces_mentioned = 1;
5191       warning_init ("missing braces around initializer");
5192     }
5193
5194   if (TREE_CODE (constructor_type) == RECORD_TYPE
5195            || TREE_CODE (constructor_type) == UNION_TYPE)
5196     {
5197       constructor_fields = TYPE_FIELDS (constructor_type);
5198       /* Skip any nameless bit fields at the beginning.  */
5199       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5200              && DECL_NAME (constructor_fields) == 0)
5201         constructor_fields = TREE_CHAIN (constructor_fields);
5202
5203       constructor_unfilled_fields = constructor_fields;
5204       constructor_bit_index = bitsize_zero_node;
5205     }
5206   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5207     {
5208       constructor_range_end = 0;
5209       if (TYPE_DOMAIN (constructor_type))
5210         {
5211           constructor_max_index
5212             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5213           constructor_index
5214             = convert (bitsizetype,
5215                                   TYPE_MIN_VALUE
5216                                   (TYPE_DOMAIN (constructor_type)));
5217         }
5218       else
5219         constructor_index = bitsize_zero_node;
5220
5221       constructor_unfilled_index = constructor_index;
5222     }
5223   else
5224     {
5225       warning_init ("braces around scalar initializer");
5226       constructor_fields = constructor_type;
5227       constructor_unfilled_fields = constructor_type;
5228     }
5229 }
5230
5231 /* Don't read a struct incrementally if it has any bitfields,
5232    because the incremental reading code doesn't know how to
5233    handle bitfields yet.  */
5234
5235 static void
5236 check_init_type_bitfields (type)
5237      tree type;
5238 {
5239   if (TREE_CODE (type) == RECORD_TYPE)
5240     {
5241       tree tail;
5242       for (tail = TYPE_FIELDS (type); tail;
5243            tail = TREE_CHAIN (tail))
5244         {
5245           if (DECL_C_BIT_FIELD (tail))
5246             {
5247               constructor_incremental = 0;
5248               break;
5249             }
5250
5251           check_init_type_bitfields (TREE_TYPE (tail));
5252         }
5253     }
5254
5255   else if (TREE_CODE (type) == UNION_TYPE)
5256     {
5257       tree tail = TYPE_FIELDS (type);
5258       if (tail && DECL_C_BIT_FIELD (tail))
5259         /* We also use the nonincremental algorithm for initiliazation
5260            of unions whose first member is a bitfield, becuase the
5261            incremental algorithm has no code for dealing with
5262            bitfields. */
5263         constructor_incremental = 0;
5264     }
5265
5266   else if (TREE_CODE (type) == ARRAY_TYPE)
5267     check_init_type_bitfields (TREE_TYPE (type));
5268 }
5269
5270 /* At the end of an implicit or explicit brace level,
5271    finish up that level of constructor.
5272    If we were outputting the elements as they are read, return 0
5273    from inner levels (process_init_element ignores that),
5274    but return error_mark_node from the outermost level
5275    (that's what we want to put in DECL_INITIAL).
5276    Otherwise, return a CONSTRUCTOR expression.  */
5277
5278 tree
5279 pop_init_level (implicit)
5280      int implicit;
5281 {
5282   struct constructor_stack *p;
5283   HOST_WIDE_INT size = 0;
5284   tree constructor = 0;
5285
5286   if (implicit == 0)
5287     {
5288       /* When we come to an explicit close brace,
5289          pop any inner levels that didn't have explicit braces.  */
5290       while (constructor_stack->implicit)
5291         process_init_element (pop_init_level (1));
5292     }
5293
5294   p = constructor_stack;
5295
5296   if (constructor_type != 0)
5297     size = int_size_in_bytes (constructor_type);
5298
5299   /* Warn when some struct elements are implicitly initialized to zero.  */
5300   if (extra_warnings
5301       && constructor_type
5302       && TREE_CODE (constructor_type) == RECORD_TYPE
5303       && constructor_unfilled_fields)
5304     {
5305       push_member_name (constructor_unfilled_fields);
5306       warning_init ("missing initializer");
5307       RESTORE_SPELLING_DEPTH (constructor_depth);
5308     }
5309
5310   /* Now output all pending elements.  */
5311   output_pending_init_elements (1);
5312
5313 #if 0 /* c-parse.in warns about {}.  */
5314   /* In ANSI, each brace level must have at least one element.  */
5315   if (! implicit && pedantic
5316       && (TREE_CODE (constructor_type) == ARRAY_TYPE
5317           ? integer_zerop (constructor_unfilled_index)
5318           : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
5319     pedwarn_init ("empty braces in initializer");
5320 #endif
5321
5322   /* Pad out the end of the structure.  */
5323
5324   if (p->replacement_value)
5325     {
5326       /* If this closes a superfluous brace pair,
5327          just pass out the element between them.  */
5328       constructor = p->replacement_value;
5329       /* If this is the top level thing within the initializer,
5330          and it's for a variable, then since we already called
5331          assemble_variable, we must output the value now.  */
5332       if (p->next == 0 && constructor_decl != 0
5333           && constructor_incremental)
5334         {
5335           constructor = digest_init (constructor_type, constructor,
5336                                      require_constant_value,
5337                                      require_constant_elements);
5338
5339           /* If initializing an array of unknown size,
5340              determine the size now.  */
5341           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5342               && TYPE_DOMAIN (constructor_type) == 0)
5343             {
5344               /* We shouldn't have an incomplete array type within
5345                  some other type.  */
5346               if (constructor_stack->next)
5347                 abort ();
5348
5349               if (complete_array_type (constructor_type, constructor, 0))
5350                 abort ();
5351
5352               size = int_size_in_bytes (constructor_type);
5353             }
5354
5355           output_constant (constructor, size);
5356         }
5357     }
5358   else if (constructor_type == 0)
5359     ;
5360   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5361            && TREE_CODE (constructor_type) != UNION_TYPE
5362            && TREE_CODE (constructor_type) != ARRAY_TYPE
5363            && ! constructor_incremental)
5364     {
5365       /* A nonincremental scalar initializer--just return
5366          the element, after verifying there is just one.  */
5367       if (constructor_elements == 0)
5368         {
5369           error_init ("empty scalar initializer");
5370           constructor = error_mark_node;
5371         }
5372       else if (TREE_CHAIN (constructor_elements) != 0)
5373         {
5374           error_init ("extra elements in scalar initializer");
5375           constructor = TREE_VALUE (constructor_elements);
5376         }
5377       else
5378         constructor = TREE_VALUE (constructor_elements);
5379     }
5380   else if (! constructor_incremental)
5381     {
5382       if (constructor_erroneous)
5383         constructor = error_mark_node;
5384       else
5385         {
5386           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5387                                nreverse (constructor_elements));
5388           if (constructor_constant)
5389             TREE_CONSTANT (constructor) = 1;
5390           if (constructor_constant && constructor_simple)
5391             TREE_STATIC (constructor) = 1;
5392         }
5393     }
5394   else
5395     {
5396       tree filled;
5397
5398       if (TREE_CODE (constructor_type) == RECORD_TYPE
5399           || TREE_CODE (constructor_type) == UNION_TYPE)
5400         /* Find the offset of the end of that field.  */
5401         filled = size_binop (CEIL_DIV_EXPR, constructor_bit_index,
5402                              bitsize_unit_node);
5403
5404       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5405         {
5406           /* If initializing an array of unknown size,
5407              determine the size now.  */
5408           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5409               && TYPE_DOMAIN (constructor_type) == 0)
5410             {
5411               tree maxindex
5412                 = copy_node (size_diffop (constructor_unfilled_index,
5413                                           bitsize_one_node));
5414
5415               TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5416               TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5417
5418               /* TYPE_MAX_VALUE is always one less than the number of elements
5419                  in the array, because we start counting at zero.  Therefore,
5420                  warn only if the value is less than zero.  */
5421               if (pedantic
5422                   && (tree_int_cst_sgn
5423                       (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5424                       < 0))
5425                 error_with_decl (constructor_decl,
5426                                  "zero or negative array size `%s'");
5427
5428               layout_type (constructor_type);
5429               size = int_size_in_bytes (constructor_type);
5430             }
5431
5432           filled
5433             = size_binop (MULT_EXPR, constructor_unfilled_index,
5434                           convert (bitsizetype,
5435                                    TYPE_SIZE_UNIT
5436                                    (TREE_TYPE (constructor_type))));
5437         }
5438       else
5439         filled = 0;
5440
5441       if (filled != 0)
5442         assemble_zeros (size - tree_low_cst (filled, 1));
5443     }
5444
5445
5446   constructor_type = p->type;
5447   constructor_fields = p->fields;
5448   constructor_index = p->index;
5449   constructor_range_end = p->range_end;
5450   constructor_max_index = p->max_index;
5451   constructor_unfilled_index = p->unfilled_index;
5452   constructor_unfilled_fields = p->unfilled_fields;
5453   constructor_bit_index = p->bit_index;
5454   constructor_elements = p->elements;
5455   constructor_constant = p->constant;
5456   constructor_simple = p->simple;
5457   constructor_erroneous = p->erroneous;
5458   constructor_pending_elts = p->pending_elts;
5459   constructor_depth = p->depth;
5460   constructor_incremental = p->incremental;
5461   RESTORE_SPELLING_DEPTH (constructor_depth);
5462
5463   constructor_stack = p->next;
5464   free (p);
5465
5466   if (constructor == 0)
5467     {
5468       if (constructor_stack == 0)
5469         return error_mark_node;
5470       return NULL_TREE;
5471     }
5472   return constructor;
5473 }
5474
5475 /* Within an array initializer, specify the next index to be initialized.
5476    FIRST is that index.  If LAST is nonzero, then initialize a range
5477    of indices, running from FIRST through LAST.  */
5478
5479 void
5480 set_init_index (first, last)
5481      tree first, last;
5482 {
5483   while ((TREE_CODE (first) == NOP_EXPR
5484           || TREE_CODE (first) == CONVERT_EXPR
5485           || TREE_CODE (first) == NON_LVALUE_EXPR)
5486          && (TYPE_MODE (TREE_TYPE (first))
5487              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5488     first = TREE_OPERAND (first, 0);
5489
5490   if (last)
5491     while ((TREE_CODE (last) == NOP_EXPR
5492             || TREE_CODE (last) == CONVERT_EXPR
5493             || TREE_CODE (last) == NON_LVALUE_EXPR)
5494            && (TYPE_MODE (TREE_TYPE (last))
5495                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5496       last = TREE_OPERAND (last, 0);
5497
5498   if (TREE_CODE (first) != INTEGER_CST)
5499     error_init ("nonconstant array index in initializer");
5500   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5501     error_init ("nonconstant array index in initializer");
5502   else if (! constructor_unfilled_index)
5503     error_init ("array index in non-array initializer");
5504   else if (tree_int_cst_lt (first, constructor_unfilled_index))
5505     error_init ("duplicate array index in initializer");
5506   else
5507     {
5508       constructor_index = convert (bitsizetype, first);
5509
5510       if (last != 0 && tree_int_cst_lt (last, first))
5511         error_init ("empty index range in initializer");
5512       else
5513         {
5514           if (pedantic)
5515             pedwarn ("ANSI C forbids specifying element to initialize");
5516
5517           constructor_range_end = last ? convert (bitsizetype, last) : 0;
5518         }
5519     }
5520 }
5521
5522 /* Within a struct initializer, specify the next field to be initialized.  */
5523
5524 void
5525 set_init_label (fieldname)
5526      tree fieldname;
5527 {
5528   tree tail;
5529   int passed = 0;
5530
5531   /* Don't die if an entire brace-pair level is superfluous
5532      in the containing level.  */
5533   if (constructor_type == 0)
5534     return;
5535
5536   for (tail = TYPE_FIELDS (constructor_type); tail;
5537        tail = TREE_CHAIN (tail))
5538     {
5539       if (tail == constructor_unfilled_fields)
5540         passed = 1;
5541       if (DECL_NAME (tail) == fieldname)
5542         break;
5543     }
5544
5545   if (tail == 0)
5546     error ("unknown field `%s' specified in initializer",
5547            IDENTIFIER_POINTER (fieldname));
5548   else if (!passed)
5549     error ("field `%s' already initialized",
5550            IDENTIFIER_POINTER (fieldname));
5551   else
5552     {
5553       constructor_fields = tail;
5554       if (pedantic)
5555         pedwarn ("ANSI C forbids specifying structure member to initialize");
5556     }
5557 }
5558 \f
5559 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5560    indentifies the initializer, either array index or field in a structure.
5561    VALUE is the value of that index or field.  */
5562
5563 static void
5564 add_pending_init (purpose, value)
5565      tree purpose, value;
5566 {
5567   struct init_node *p, **q, *r;
5568
5569   q = &constructor_pending_elts;
5570   p = 0;
5571
5572   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5573     {
5574       while (*q != 0)
5575         {
5576           p = *q;
5577           if (tree_int_cst_lt (purpose, p->purpose))
5578             q = &p->left;
5579           else if (p->purpose != purpose)
5580             q = &p->right;
5581           else
5582             abort ();
5583         }
5584     }
5585   else
5586     {
5587       while (*q != NULL)
5588         {
5589           p = *q;
5590           if (tree_int_cst_lt (bit_position (purpose),
5591                                bit_position (p->purpose)))
5592             q = &p->left;
5593           else if (p->purpose != purpose)
5594             q = &p->right;
5595           else
5596             abort ();
5597         }
5598     }
5599
5600   r = (struct init_node *) ggc_alloc_obj (sizeof (struct init_node), 0);
5601   r->purpose = purpose;
5602   r->value = value;
5603
5604   *q = r;
5605   r->parent = p;
5606   r->left = 0;
5607   r->right = 0;
5608   r->balance = 0;
5609
5610   while (p)
5611     {
5612       struct init_node *s;
5613
5614       if (r == p->left)
5615         {
5616           if (p->balance == 0)
5617             p->balance = -1;
5618           else if (p->balance < 0)
5619             {
5620               if (r->balance < 0)
5621                 {
5622                   /* L rotation. */
5623                   p->left = r->right;
5624                   if (p->left)
5625                     p->left->parent = p;
5626                   r->right = p;
5627
5628                   p->balance = 0;
5629                   r->balance = 0;
5630
5631                   s = p->parent;
5632                   p->parent = r;
5633                   r->parent = s;
5634                   if (s)
5635                     {
5636                       if (s->left == p)
5637                         s->left = r;
5638                       else
5639                         s->right = r;
5640                     }
5641                   else
5642                     constructor_pending_elts = r;
5643                 }
5644               else
5645                 {
5646                   /* LR rotation. */
5647                   struct init_node *t = r->right;
5648
5649                   r->right = t->left;
5650                   if (r->right)
5651                     r->right->parent = r;
5652                   t->left = r;
5653
5654                   p->left = t->right;
5655                   if (p->left)
5656                     p->left->parent = p;
5657                   t->right = p;
5658
5659                   p->balance = t->balance < 0;
5660                   r->balance = -(t->balance > 0);
5661                   t->balance = 0;
5662
5663                   s = p->parent;
5664                   p->parent = t;
5665                   r->parent = t;
5666                   t->parent = s;
5667                   if (s)
5668                     {
5669                       if (s->left == p)
5670                         s->left = t;
5671                       else
5672                         s->right = t;
5673                     }
5674                   else
5675                     constructor_pending_elts = t;
5676                 }
5677               break;
5678             }
5679           else
5680             {
5681               /* p->balance == +1; growth of left side balances the node.  */
5682               p->balance = 0;
5683               break;
5684             }
5685         }
5686       else /* r == p->right */
5687         {
5688           if (p->balance == 0)
5689             /* Growth propagation from right side.  */
5690             p->balance++;
5691           else if (p->balance > 0)
5692             {
5693               if (r->balance > 0)
5694                 {
5695                   /* R rotation. */
5696                   p->right = r->left;
5697                   if (p->right)
5698                     p->right->parent = p;
5699                   r->left = p;
5700
5701                   p->balance = 0;
5702                   r->balance = 0;
5703
5704                   s = p->parent;
5705                   p->parent = r;
5706                   r->parent = s;
5707                   if (s)
5708                     {
5709                       if (s->left == p)
5710                         s->left = r;
5711                       else
5712                         s->right = r;
5713                     }
5714                   else
5715                     constructor_pending_elts = r;
5716                 }
5717               else /* r->balance == -1 */
5718                 {
5719                   /* RL rotation */
5720                   struct init_node *t = r->left;
5721
5722                   r->left = t->right;
5723                   if (r->left)
5724                     r->left->parent = r;
5725                   t->right = r;
5726
5727                   p->right = t->left;
5728                   if (p->right)
5729                     p->right->parent = p;
5730                   t->left = p;
5731
5732                   r->balance = (t->balance < 0);
5733                   p->balance = -(t->balance > 0);
5734                   t->balance = 0;
5735
5736                   s = p->parent;
5737                   p->parent = t;
5738                   r->parent = t;
5739                   t->parent = s;
5740                   if (s)
5741                     {
5742                       if (s->left == p)
5743                         s->left = t;
5744                       else
5745                         s->right = t;
5746                     }
5747                   else
5748                     constructor_pending_elts = t;
5749                 }
5750               break;
5751             }
5752           else
5753             {
5754               /* p->balance == -1; growth of right side balances the node. */
5755               p->balance = 0;
5756               break;
5757             }
5758         }
5759
5760       r = p;
5761       p = p->parent;
5762     }
5763 }
5764
5765 /* Return nonzero if FIELD is equal to the index of a pending initializer.  */
5766
5767 static int
5768 pending_init_member (field)
5769      tree field;
5770 {
5771   struct init_node *p;
5772
5773   p = constructor_pending_elts;
5774   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5775     {
5776       while (p)
5777         {
5778           if (field == p->purpose)
5779             return 1;
5780           else if (tree_int_cst_lt (field, p->purpose))
5781             p = p->left;
5782           else
5783             p = p->right;
5784         }
5785     }
5786   else
5787     {
5788       while (p)
5789         {
5790           if (field == p->purpose)
5791             return 1;
5792           else if (tree_int_cst_lt (bit_position (field),
5793                                     bit_position (p->purpose)))
5794             p = p->left;
5795           else
5796             p = p->right;
5797         }
5798     }
5799
5800   return 0;
5801 }
5802
5803 /* "Output" the next constructor element.
5804    At top level, really output it to assembler code now.
5805    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5806    TYPE is the data type that the containing data type wants here.
5807    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5808
5809    PENDING if non-nil means output pending elements that belong
5810    right after this element.  (PENDING is normally 1;
5811    it is 0 while outputting pending elements, to avoid recursion.)  */
5812
5813 static void
5814 output_init_element (value, type, field, pending)
5815      tree value, type, field;
5816      int pending;
5817 {
5818   int duplicate = 0;
5819
5820   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5821       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5822           && !(TREE_CODE (value) == STRING_CST
5823                && TREE_CODE (type) == ARRAY_TYPE
5824                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5825           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5826                          TYPE_MAIN_VARIANT (type))))
5827     value = default_conversion (value);
5828
5829   if (value == error_mark_node)
5830     constructor_erroneous = 1;
5831   else if (!TREE_CONSTANT (value))
5832     constructor_constant = 0;
5833   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5834            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5835                 || TREE_CODE (constructor_type) == UNION_TYPE)
5836                && DECL_C_BIT_FIELD (field)
5837                && TREE_CODE (value) != INTEGER_CST))
5838     constructor_simple = 0;
5839
5840   if (require_constant_value && ! TREE_CONSTANT (value))
5841     {
5842       error_init ("initializer element is not constant");
5843       value = error_mark_node;
5844     }
5845   else if (require_constant_elements
5846            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5847     {
5848       error_init ("initializer element is not computable at load time");
5849       value = error_mark_node;
5850     }
5851
5852   /* If this element duplicates one on constructor_pending_elts,
5853      print a message and ignore it.  Don't do this when we're
5854      processing elements taken off constructor_pending_elts,
5855      because we'd always get spurious errors.  */
5856   if (pending)
5857     {
5858       if (TREE_CODE (constructor_type) == RECORD_TYPE
5859           || TREE_CODE (constructor_type) == UNION_TYPE
5860           || TREE_CODE (constructor_type) == ARRAY_TYPE)
5861         {
5862           if (pending_init_member (field))
5863             {
5864               error_init ("duplicate initializer");
5865               duplicate = 1;
5866             }
5867         }
5868     }
5869
5870   /* If this element doesn't come next in sequence,
5871      put it on constructor_pending_elts.  */
5872   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5873       && ! tree_int_cst_equal (field, constructor_unfilled_index))
5874     {
5875       if (! duplicate)
5876         add_pending_init (field,
5877                           digest_init (type, value, require_constant_value,
5878                                        require_constant_elements));
5879     }
5880   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5881            && field != constructor_unfilled_fields)
5882     {
5883       /* We do this for records but not for unions.  In a union,
5884          no matter which field is specified, it can be initialized
5885          right away since it starts at the beginning of the union.  */
5886       if (!duplicate)
5887         add_pending_init (field,
5888                           digest_init (type, value, require_constant_value,
5889                                        require_constant_elements));
5890     }
5891   else
5892     {
5893       /* Otherwise, output this element either to
5894          constructor_elements or to the assembler file.  */
5895
5896       if (!duplicate)
5897         {
5898           if (! constructor_incremental)
5899             {
5900               if (field && TREE_CODE (field) == INTEGER_CST)
5901                 field = copy_node (field);
5902               constructor_elements
5903                 = tree_cons (field, digest_init (type, value,
5904                                                  require_constant_value,
5905                                                  require_constant_elements),
5906                              constructor_elements);
5907             }
5908           else
5909             {
5910               /* Structure elements may require alignment.
5911                  Do this, if necessary.  */
5912               if (TREE_CODE (constructor_type) == RECORD_TYPE
5913                   && ! tree_int_cst_equal (constructor_bit_index,
5914                                            bit_position (field)))
5915                 /* Advance to offset of this element.  */
5916                 assemble_zeros
5917                   (tree_low_cst
5918                    (size_binop (TRUNC_DIV_EXPR,
5919                                 size_binop (MINUS_EXPR, bit_position (field),
5920                                             constructor_bit_index),
5921                                 bitsize_unit_node),
5922                     0));
5923
5924               output_constant (digest_init (type, value,
5925                                             require_constant_value,
5926                                             require_constant_elements),
5927                                int_size_in_bytes (type));
5928
5929               /* For a record or union,
5930                  keep track of end position of last field.  */
5931               if (TREE_CODE (constructor_type) == RECORD_TYPE
5932                   || TREE_CODE (constructor_type) == UNION_TYPE)
5933                 constructor_bit_index
5934                   = size_binop (PLUS_EXPR, bit_position (field),
5935                                 DECL_SIZE (field));
5936             }
5937         }
5938
5939       /* Advance the variable that indicates sequential elements output.  */
5940       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5941         constructor_unfilled_index
5942           = size_binop (PLUS_EXPR, constructor_unfilled_index,
5943                         bitsize_one_node);
5944       else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5945         {
5946           constructor_unfilled_fields
5947             = TREE_CHAIN (constructor_unfilled_fields);
5948
5949           /* Skip any nameless bit fields.  */
5950           while (constructor_unfilled_fields != 0
5951                  && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5952                  && DECL_NAME (constructor_unfilled_fields) == 0)
5953             constructor_unfilled_fields =
5954               TREE_CHAIN (constructor_unfilled_fields);
5955         }
5956       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5957         constructor_unfilled_fields = 0;
5958
5959       /* Now output any pending elements which have become next.  */
5960       if (pending)
5961         output_pending_init_elements (0);
5962     }
5963 }
5964
5965 /* Output any pending elements which have become next.
5966    As we output elements, constructor_unfilled_{fields,index}
5967    advances, which may cause other elements to become next;
5968    if so, they too are output.
5969
5970    If ALL is 0, we return when there are
5971    no more pending elements to output now.
5972
5973    If ALL is 1, we output space as necessary so that
5974    we can output all the pending elements.  */
5975
5976 static void
5977 output_pending_init_elements (all)
5978      int all;
5979 {
5980   struct init_node *elt = constructor_pending_elts;
5981   tree next;
5982
5983  retry:
5984
5985   /* Look thru the whole pending tree.
5986      If we find an element that should be output now,
5987      output it.  Otherwise, set NEXT to the element
5988      that comes first among those still pending.  */
5989
5990   next = 0;
5991   while (elt)
5992     {
5993       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5994         {
5995           if (tree_int_cst_equal (elt->purpose,
5996                                   constructor_unfilled_index))
5997             output_init_element (elt->value,
5998                                  TREE_TYPE (constructor_type),
5999                                  constructor_unfilled_index, 0);
6000           else if (tree_int_cst_lt (constructor_unfilled_index,
6001                                     elt->purpose))
6002             {
6003               /* Advance to the next smaller node.  */
6004               if (elt->left)
6005                 elt = elt->left;
6006               else
6007                 {
6008                   /* We have reached the smallest node bigger than the
6009                      current unfilled index.  Fill the space first.  */
6010                   next = elt->purpose;
6011                   break;
6012                 }
6013             }
6014           else
6015             {
6016               /* Advance to the next bigger node.  */
6017               if (elt->right)
6018                 elt = elt->right;
6019               else
6020                 {
6021                   /* We have reached the biggest node in a subtree.  Find
6022                      the parent of it, which is the next bigger node.  */
6023                   while (elt->parent && elt->parent->right == elt)
6024                     elt = elt->parent;
6025                   elt = elt->parent;
6026                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6027                                               elt->purpose))
6028                     {
6029                       next = elt->purpose;
6030                       break;
6031                     }
6032                 }
6033             }
6034         }
6035       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6036                || TREE_CODE (constructor_type) == UNION_TYPE)
6037         {
6038           /* If the current record is complete we are done.  */
6039           if (constructor_unfilled_fields == 0)
6040             break;
6041           if (elt->purpose == constructor_unfilled_fields)
6042             {
6043               output_init_element (elt->value,
6044                                    TREE_TYPE (constructor_unfilled_fields),
6045                                    constructor_unfilled_fields,
6046                                    0);
6047             }
6048           else if (tree_int_cst_lt (bit_position (constructor_unfilled_fields),
6049                                     bit_position (elt->purpose)))
6050             {
6051               /* Advance to the next smaller node.  */
6052               if (elt->left)
6053                 elt = elt->left;
6054               else
6055                 {
6056                   /* We have reached the smallest node bigger than the
6057                      current unfilled field.  Fill the space first.  */
6058                   next = elt->purpose;
6059                   break;
6060                 }
6061             }
6062           else
6063             {
6064               /* Advance to the next bigger node.  */
6065               if (elt->right)
6066                 elt = elt->right;
6067               else
6068                 {
6069                   /* We have reached the biggest node in a subtree.  Find
6070                      the parent of it, which is the next bigger node.  */
6071                   while (elt->parent && elt->parent->right == elt)
6072                     elt = elt->parent;
6073                   elt = elt->parent;
6074                   if (elt
6075                       && (tree_int_cst_lt
6076                           (bit_position (constructor_unfilled_fields),
6077                            bit_position (elt->purpose))))
6078                     {
6079                       next = elt->purpose;
6080                       break;
6081                     }
6082                 }
6083             }
6084         }
6085     }
6086
6087   /* Ordinarily return, but not if we want to output all
6088      and there are elements left.  */
6089   if (! (all && next != 0))
6090     return;
6091
6092   /* Generate space up to the position of NEXT.  */
6093   if (constructor_incremental)
6094     {
6095       tree filled;
6096       tree nextpos_tree = bitsize_zero_node;
6097
6098       if (TREE_CODE (constructor_type) == RECORD_TYPE
6099           || TREE_CODE (constructor_type) == UNION_TYPE)
6100         {
6101           tree tail;
6102
6103           /* Find the last field written out, if any.  */
6104           for (tail = TYPE_FIELDS (constructor_type); tail;
6105                tail = TREE_CHAIN (tail))
6106             if (TREE_CHAIN (tail) == constructor_unfilled_fields)
6107               break;
6108
6109           if (tail)
6110             /* Find the offset of the end of that field.  */
6111             filled = size_binop (CEIL_DIV_EXPR,
6112                                  size_binop (PLUS_EXPR, bit_position (tail),
6113                                              DECL_SIZE (tail)),
6114                                  bitsize_unit_node);
6115           else
6116             filled = bitsize_zero_node;
6117
6118           nextpos_tree = convert (bitsizetype, byte_position (next));
6119           constructor_bit_index = bit_position (next);
6120           constructor_unfilled_fields = next;
6121         }
6122       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6123         {
6124           filled
6125             = size_binop (MULT_EXPR, constructor_unfilled_index,
6126                           convert (bitsizetype,
6127                                    TYPE_SIZE_UNIT
6128                                    (TREE_TYPE (constructor_type))));
6129           nextpos_tree
6130             = size_binop (MULT_EXPR, next,
6131                           convert (bitsizetype, TYPE_SIZE_UNIT
6132                                    (TREE_TYPE (constructor_type))));
6133           constructor_unfilled_index = next;
6134         }
6135       else
6136         filled = 0;
6137
6138       if (filled)
6139         assemble_zeros (tree_low_cst (size_diffop (nextpos_tree, filled), 1));
6140     }
6141   else
6142     {
6143       /* If it's not incremental, just skip over the gap,
6144          so that after jumping to retry we will output the next
6145          successive element.  */
6146       if (TREE_CODE (constructor_type) == RECORD_TYPE
6147           || TREE_CODE (constructor_type) == UNION_TYPE)
6148         constructor_unfilled_fields = next;
6149       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6150         constructor_unfilled_index = next;
6151     }
6152
6153   /* ELT now points to the node in the pending tree with the next
6154      initializer to output.  */
6155   goto retry;
6156 }
6157 \f
6158 /* Add one non-braced element to the current constructor level.
6159    This adjusts the current position within the constructor's type.
6160    This may also start or terminate implicit levels
6161    to handle a partly-braced initializer.
6162
6163    Once this has found the correct level for the new element,
6164    it calls output_init_element.
6165
6166    Note: if we are incrementally outputting this constructor,
6167    this function may be called with a null argument
6168    representing a sub-constructor that was already incrementally output.
6169    When that happens, we output nothing, but we do the bookkeeping
6170    to skip past that element of the current constructor.  */
6171
6172 void
6173 process_init_element (value)
6174      tree value;
6175 {
6176   tree orig_value = value;
6177   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6178
6179   /* Handle superfluous braces around string cst as in
6180      char x[] = {"foo"}; */
6181   if (string_flag
6182       && constructor_type
6183       && TREE_CODE (constructor_type) == ARRAY_TYPE
6184       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6185       && integer_zerop (constructor_unfilled_index))
6186     {
6187       if (constructor_stack->replacement_value)
6188         error_init ("excess elements in char array initializer");
6189       constructor_stack->replacement_value = value;
6190       return;
6191     }
6192
6193   if (constructor_stack->replacement_value != 0)
6194     {
6195       error_init ("excess elements in struct initializer");
6196       return;
6197     }
6198
6199   /* Ignore elements of a brace group if it is entirely superfluous
6200      and has already been diagnosed.  */
6201   if (constructor_type == 0)
6202     return;
6203
6204   /* If we've exhausted any levels that didn't have braces,
6205      pop them now.  */
6206   while (constructor_stack->implicit)
6207     {
6208       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6209            || TREE_CODE (constructor_type) == UNION_TYPE)
6210           && constructor_fields == 0)
6211         process_init_element (pop_init_level (1));
6212       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6213                && (constructor_max_index == 0
6214                    || tree_int_cst_lt (constructor_max_index,
6215                                        constructor_index)))
6216         process_init_element (pop_init_level (1));
6217       else
6218         break;
6219     }
6220
6221   while (1)
6222     {
6223       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6224         {
6225           tree fieldtype;
6226           enum tree_code fieldcode;
6227
6228           if (constructor_fields == 0)
6229             {
6230               pedwarn_init ("excess elements in struct initializer");
6231               break;
6232             }
6233
6234           fieldtype = TREE_TYPE (constructor_fields);
6235           if (fieldtype != error_mark_node)
6236             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6237           fieldcode = TREE_CODE (fieldtype);
6238
6239           /* Accept a string constant to initialize a subarray.  */
6240           if (value != 0
6241               && fieldcode == ARRAY_TYPE
6242               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6243               && string_flag)
6244             value = orig_value;
6245           /* Otherwise, if we have come to a subaggregate,
6246              and we don't have an element of its type, push into it.  */
6247           else if (value != 0 && !constructor_no_implicit
6248                    && value != error_mark_node
6249                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6250                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6251                        || fieldcode == UNION_TYPE))
6252             {
6253               push_init_level (1);
6254               continue;
6255             }
6256
6257           if (value)
6258             {
6259               push_member_name (constructor_fields);
6260               output_init_element (value, fieldtype, constructor_fields, 1);
6261               RESTORE_SPELLING_DEPTH (constructor_depth);
6262             }
6263           else
6264             /* Do the bookkeeping for an element that was
6265                directly output as a constructor.  */
6266             {
6267               /* For a record, keep track of end position of last field.  */
6268               constructor_bit_index
6269                 = size_binop (PLUS_EXPR,
6270                               bit_position (constructor_fields),
6271                               DECL_SIZE (constructor_fields));
6272
6273               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6274               /* Skip any nameless bit fields.  */
6275               while (constructor_unfilled_fields != 0
6276                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6277                      && DECL_NAME (constructor_unfilled_fields) == 0)
6278                 constructor_unfilled_fields =
6279                   TREE_CHAIN (constructor_unfilled_fields);
6280             }
6281
6282           constructor_fields = TREE_CHAIN (constructor_fields);
6283           /* Skip any nameless bit fields at the beginning.  */
6284           while (constructor_fields != 0
6285                  && DECL_C_BIT_FIELD (constructor_fields)
6286                  && DECL_NAME (constructor_fields) == 0)
6287             constructor_fields = TREE_CHAIN (constructor_fields);
6288           break;
6289         }
6290       if (TREE_CODE (constructor_type) == UNION_TYPE)
6291         {
6292           tree fieldtype;
6293           enum tree_code fieldcode;
6294
6295           if (constructor_fields == 0)
6296             {
6297               pedwarn_init ("excess elements in union initializer");
6298               break;
6299             }
6300
6301           fieldtype = TREE_TYPE (constructor_fields);
6302           if (fieldtype != error_mark_node)
6303             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6304           fieldcode = TREE_CODE (fieldtype);
6305
6306           /* Accept a string constant to initialize a subarray.  */
6307           if (value != 0
6308               && fieldcode == ARRAY_TYPE
6309               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6310               && string_flag)
6311             value = orig_value;
6312           /* Otherwise, if we have come to a subaggregate,
6313              and we don't have an element of its type, push into it.  */
6314           else if (value != 0 && !constructor_no_implicit
6315                    && value != error_mark_node
6316                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6317                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6318                        || fieldcode == UNION_TYPE))
6319             {
6320               push_init_level (1);
6321               continue;
6322             }
6323
6324           if (value)
6325             {
6326               push_member_name (constructor_fields);
6327               output_init_element (value, fieldtype, constructor_fields, 1);
6328               RESTORE_SPELLING_DEPTH (constructor_depth);
6329             }
6330           else
6331             /* Do the bookkeeping for an element that was
6332                directly output as a constructor.  */
6333             {
6334               constructor_bit_index = DECL_SIZE (constructor_fields);
6335               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6336             }
6337
6338           constructor_fields = 0;
6339           break;
6340         }
6341       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6342         {
6343           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6344           enum tree_code eltcode = TREE_CODE (elttype);
6345
6346           /* Accept a string constant to initialize a subarray.  */
6347           if (value != 0
6348               && eltcode == ARRAY_TYPE
6349               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6350               && string_flag)
6351             value = orig_value;
6352           /* Otherwise, if we have come to a subaggregate,
6353              and we don't have an element of its type, push into it.  */
6354           else if (value != 0 && !constructor_no_implicit
6355                    && value != error_mark_node
6356                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6357                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6358                        || eltcode == UNION_TYPE))
6359             {
6360               push_init_level (1);
6361               continue;
6362             }
6363
6364           if (constructor_max_index != 0
6365               && tree_int_cst_lt (constructor_max_index, constructor_index))
6366             {
6367               pedwarn_init ("excess elements in array initializer");
6368               break;
6369             }
6370
6371           /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once.  */
6372           if (constructor_range_end)
6373             {
6374               if (constructor_max_index != 0
6375                   && tree_int_cst_lt (constructor_max_index,
6376                                       constructor_range_end))
6377                 {
6378                   pedwarn_init ("excess elements in array initializer");
6379                   constructor_range_end = constructor_max_index;
6380                 }
6381
6382               value = save_expr (value);
6383             }
6384
6385           /* Now output the actual element.
6386              Ordinarily, output once.
6387              If there is a range, repeat it till we advance past the range.  */
6388           do
6389             {
6390               if (value)
6391                 {
6392                   push_array_bounds (tree_low_cst (constructor_index, 0));
6393                   output_init_element (value, elttype, constructor_index, 1);
6394                   RESTORE_SPELLING_DEPTH (constructor_depth);
6395                 }
6396
6397               constructor_index
6398                 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6399
6400               if (! value)
6401                 /* If we are doing the bookkeeping for an element that was
6402                    directly output as a constructor, we must update
6403                    constructor_unfilled_index.  */
6404                 constructor_unfilled_index = constructor_index;
6405             }
6406           while (! (constructor_range_end == 0
6407                     || tree_int_cst_lt (constructor_range_end,
6408                                         constructor_index)));
6409
6410           break;
6411         }
6412
6413       /* Handle the sole element allowed in a braced initializer
6414          for a scalar variable.  */
6415       if (constructor_fields == 0)
6416         {
6417           pedwarn_init ("excess elements in scalar initializer");
6418           break;
6419         }
6420
6421       if (value)
6422         output_init_element (value, constructor_type, NULL_TREE, 1);
6423       constructor_fields = 0;
6424       break;
6425     }
6426 }
6427 \f
6428 /* Expand an ASM statement with operands, handling output operands
6429    that are not variables or INDIRECT_REFS by transforming such
6430    cases into cases that expand_asm_operands can handle.
6431
6432    Arguments are same as for expand_asm_operands.  */
6433
6434 void
6435 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6436      tree string, outputs, inputs, clobbers;
6437      int vol;
6438      char *filename;
6439      int line;
6440 {
6441   int noutputs = list_length (outputs);
6442   register int i;
6443   /* o[I] is the place that output number I should be written.  */
6444   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6445   register tree tail;
6446
6447   if (TREE_CODE (string) == ADDR_EXPR)
6448     string = TREE_OPERAND (string, 0);
6449   if (TREE_CODE (string) != STRING_CST)
6450     {
6451       error ("asm template is not a string constant");
6452       return;
6453     }
6454
6455   /* Record the contents of OUTPUTS before it is modified.  */
6456   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6457     {
6458       tree output = TREE_VALUE (tail);
6459
6460       /* We can remove conversions that just change the type, not the mode.  */
6461       STRIP_NOPS (output);
6462       o[i] = output;
6463
6464       /* Allow conversions as LHS here.  build_modify_expr as called below
6465          will do the right thing with them.  */
6466       while (TREE_CODE (output) == NOP_EXPR
6467              || TREE_CODE (output) == CONVERT_EXPR
6468              || TREE_CODE (output) == FLOAT_EXPR
6469              || TREE_CODE (output) == FIX_TRUNC_EXPR
6470              || TREE_CODE (output) == FIX_FLOOR_EXPR
6471              || TREE_CODE (output) == FIX_ROUND_EXPR
6472              || TREE_CODE (output) == FIX_CEIL_EXPR)
6473         output = TREE_OPERAND (output, 0);
6474
6475       lvalue_or_else (o[i], "invalid lvalue in asm statement");
6476     }
6477
6478   /* Perform default conversions on array and function inputs.  */
6479   /* Don't do this for other types--
6480      it would screw up operands expected to be in memory.  */
6481   for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6482     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6483         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6484       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6485
6486   /* Generate the ASM_OPERANDS insn;
6487      store into the TREE_VALUEs of OUTPUTS some trees for
6488      where the values were actually stored.  */
6489   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6490
6491   /* Copy all the intermediate outputs into the specified outputs.  */
6492   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6493     {
6494       if (o[i] != TREE_VALUE (tail))
6495         {
6496           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6497                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6498           free_temp_slots ();
6499         }
6500       /* Detect modification of read-only values.
6501          (Otherwise done by build_modify_expr.)  */
6502       else
6503         {
6504           tree type = TREE_TYPE (o[i]);
6505           if (TREE_READONLY (o[i])
6506               || TYPE_READONLY (type)
6507               || ((TREE_CODE (type) == RECORD_TYPE
6508                    || TREE_CODE (type) == UNION_TYPE)
6509                   && C_TYPE_FIELDS_READONLY (type)))
6510             readonly_warning (o[i], "modification by `asm'");
6511         }
6512     }
6513
6514   /* Those MODIFY_EXPRs could do autoincrements.  */
6515   emit_queue ();
6516 }
6517 \f
6518 /* Expand a C `return' statement.
6519    RETVAL is the expression for what to return,
6520    or a null pointer for `return;' with no value.  */
6521
6522 void
6523 c_expand_return (retval)
6524      tree retval;
6525 {
6526   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6527
6528   if (TREE_THIS_VOLATILE (current_function_decl))
6529     warning ("function declared `noreturn' has a `return' statement");
6530
6531   if (!retval)
6532     {
6533       current_function_returns_null = 1;
6534       if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6535         warning ("`return' with no value, in function returning non-void");
6536       expand_null_return ();
6537     }
6538   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6539     {
6540       current_function_returns_null = 1;
6541       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6542         pedwarn ("`return' with a value, in function returning void");
6543       expand_return (retval);
6544     }
6545   else
6546     {
6547       tree t = convert_for_assignment (valtype, retval, _("return"),
6548                                        NULL_TREE, NULL_TREE, 0);
6549       tree res = DECL_RESULT (current_function_decl);
6550       tree inner;
6551
6552       if (t == error_mark_node)
6553         return;
6554
6555       inner = t = convert (TREE_TYPE (res), t);
6556
6557       /* Strip any conversions, additions, and subtractions, and see if
6558          we are returning the address of a local variable.  Warn if so.  */
6559       while (1)
6560         {
6561           switch (TREE_CODE (inner))
6562             {
6563             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6564             case PLUS_EXPR:
6565               inner = TREE_OPERAND (inner, 0);
6566               continue;
6567
6568             case MINUS_EXPR:
6569               /* If the second operand of the MINUS_EXPR has a pointer
6570                  type (or is converted from it), this may be valid, so
6571                  don't give a warning.  */
6572               {
6573                 tree op1 = TREE_OPERAND (inner, 1);
6574
6575                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6576                        && (TREE_CODE (op1) == NOP_EXPR
6577                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6578                            || TREE_CODE (op1) == CONVERT_EXPR))
6579                   op1 = TREE_OPERAND (op1, 0);
6580
6581                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6582                   break;
6583
6584                 inner = TREE_OPERAND (inner, 0);
6585                 continue;
6586               }
6587
6588             case ADDR_EXPR:
6589               inner = TREE_OPERAND (inner, 0);
6590
6591               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6592                 inner = TREE_OPERAND (inner, 0);
6593
6594               if (TREE_CODE (inner) == VAR_DECL
6595                   && ! DECL_EXTERNAL (inner)
6596                   && ! TREE_STATIC (inner)
6597                   && DECL_CONTEXT (inner) == current_function_decl)
6598                 warning ("function returns address of local variable");
6599               break;
6600
6601             default:
6602               break;
6603             }
6604
6605           break;
6606         }
6607
6608       t = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6609       TREE_SIDE_EFFECTS (t) = 1;
6610       expand_return (t);
6611       current_function_returns_value = 1;
6612     }
6613 }
6614 \f
6615 /* Start a C switch statement, testing expression EXP.
6616    Return EXP if it is valid, an error node otherwise.  */
6617
6618 tree
6619 c_expand_start_case (exp)
6620      tree exp;
6621 {
6622   register enum tree_code code;
6623   tree type;
6624
6625   if (TREE_CODE (exp) == ERROR_MARK)
6626     return exp;
6627
6628   code = TREE_CODE (TREE_TYPE (exp));
6629   type = TREE_TYPE (exp);
6630
6631   if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
6632     {
6633       error ("switch quantity not an integer");
6634       exp = error_mark_node;
6635     }
6636   else
6637     {
6638       tree index;
6639       type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6640
6641       if (warn_traditional
6642           && ! in_system_header
6643           && (type == long_integer_type_node
6644               || type == long_unsigned_type_node))
6645         pedwarn ("`long' switch expression not converted to `int' in ANSI C");
6646
6647       exp = default_conversion (exp);
6648       type = TREE_TYPE (exp);
6649       index = get_unwidened (exp, NULL_TREE);
6650       /* We can't strip a conversion from a signed type to an unsigned,
6651          because if we did, int_fits_type_p would do the wrong thing
6652          when checking case values for being in range,
6653          and it's too hard to do the right thing.  */
6654       if (TREE_UNSIGNED (TREE_TYPE (exp))
6655           == TREE_UNSIGNED (TREE_TYPE (index)))
6656         exp = index;
6657     }
6658
6659   expand_start_case (1, exp, type, "switch statement");
6660
6661   return exp;
6662 }