gcc/c-typeck.c

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