gcc/c-typeck.c

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