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               xop0 = orig_op0;
2394               xop1 = orig_op1;
2395               STRIP_TYPE_NOPS (xop0);
2396               STRIP_TYPE_NOPS (xop1);
2397
2398               /* Give warnings for comparisons between signed and unsigned
2399                  quantities that may fail.  */
2400               /* Do the checking based on the original operand trees, so that
2401                  casts will be considered, but default promotions won't be.  */
2402
2403               /* Do not warn if the comparison is being done in a signed type,
2404                  since the signed type will only be chosen if it can represent
2405                  all the values of the unsigned type.  */
2406               if (! TREE_UNSIGNED (result_type))
2407                 /* OK */;
2408               /* Do not warn if both operands are the same signedness.  */
2409               else if (op0_signed == op1_signed)
2410                 /* OK */;
2411               else
2412                 {
2413                   tree sop, uop;
2414                   if (op0_signed)
2415                     sop = xop0, uop = xop1;
2416                   else
2417                     sop = xop1, uop = xop0;
2418
2419                   /* Do not warn if the signed quantity is an unsuffixed
2420                      integer literal (or some static constant expression
2421                      involving such literals) and it is non-negative.  */
2422                   if (TREE_CODE (sop) == INTEGER_CST
2423                       && tree_int_cst_sgn (sop) >= 0)
2424                     /* OK */;
2425                   /* Do not warn if the comparison is an equality operation,
2426                      the unsigned quantity is an integral constant, and it
2427                      would fit in the result if the result were signed.  */
2428                   else if (TREE_CODE (uop) == INTEGER_CST
2429                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2430                            && int_fits_type_p (uop, signed_type (result_type)))
2431                     /* OK */;
2432                   /* Do not warn if the unsigned quantity is an enumeration
2433                      constant and its maximum value would fit in the result
2434                      if the result were signed.  */
2435                   else if (TREE_CODE (uop) == INTEGER_CST
2436                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2437                            && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2438                                                signed_type (result_type)))
2439                     /* OK */;
2440                   else
2441                     warning ("comparison between signed and unsigned");
2442                 }
2443
2444               /* Warn if two unsigned values are being compared in a size
2445                  larger than their original size, and one (and only one) is the
2446                  result of a `~' operator.  This comparison will always fail.
2447
2448                  Also warn if one operand is a constant, and the constant
2449                  does not have all bits set that are set in the ~ operand
2450                  when it is extended.  */
2451
2452               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2453                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2454                 {
2455                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2456                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2457                                             &unsignedp0);
2458                   else
2459                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2460                                             &unsignedp1);
2461
2462                   if (TREE_CODE (primop0) == INTEGER_CST
2463                       || TREE_CODE (primop1) == INTEGER_CST)
2464                     {
2465                       tree primop;
2466                       long constant, mask;
2467                       int unsignedp, bits;
2468
2469                       if (TREE_CODE (primop0) == INTEGER_CST)
2470                         {
2471                           primop = primop1;
2472                           unsignedp = unsignedp1;
2473                           constant = TREE_INT_CST_LOW (primop0);
2474                         }
2475                       else
2476                         {
2477                           primop = primop0;
2478                           unsignedp = unsignedp0;
2479                           constant = TREE_INT_CST_LOW (primop1);
2480                         }
2481
2482                       bits = TYPE_PRECISION (TREE_TYPE (primop));
2483                       if (bits < TYPE_PRECISION (result_type)
2484                           && bits < HOST_BITS_PER_LONG && unsignedp)
2485                         {
2486                           mask = (~0L) << bits;
2487                           if ((mask & constant) != mask)
2488                             warning ("comparison of promoted ~unsigned with constant");
2489                         }
2490                     }
2491                   else if (unsignedp0 && unsignedp1
2492                            && (TYPE_PRECISION (TREE_TYPE (primop0))
2493                                < TYPE_PRECISION (result_type))
2494                            && (TYPE_PRECISION (TREE_TYPE (primop1))
2495                                < TYPE_PRECISION (result_type)))
2496                     warning ("comparison of promoted ~unsigned with unsigned");
2497                 }
2498             }
2499         }
2500     }
2501
2502   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2503      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2504      Then the expression will be built.
2505      It will be given type FINAL_TYPE if that is nonzero;
2506      otherwise, it will be given type RESULT_TYPE.  */
2507
2508   if (!result_type)
2509     {
2510       binary_op_error (code);
2511       return error_mark_node;
2512     }
2513
2514   if (! converted)
2515     {
2516       if (TREE_TYPE (op0) != result_type)
2517         op0 = convert (result_type, op0);
2518       if (TREE_TYPE (op1) != result_type)
2519         op1 = convert (result_type, op1);
2520     }
2521
2522   if (build_type == NULL_TREE)
2523     build_type = result_type;
2524
2525   {
2526     register tree result = build (resultcode, build_type, op0, op1);
2527     register tree folded;
2528
2529     folded = fold (result);
2530     if (folded == result)
2531       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2532     if (final_type != 0)
2533       return convert (final_type, folded);
2534     return folded;
2535   }
2536 }
2537 \f
2538 /* Return a tree for the sum or difference (RESULTCODE says which)
2539    of pointer PTROP and integer INTOP.  */
2540
2541 static tree
2542 pointer_int_sum (resultcode, ptrop, intop)
2543      enum tree_code resultcode;
2544      register tree ptrop, intop;
2545 {
2546   tree size_exp;
2547
2548   register tree result;
2549   register tree folded;
2550
2551   /* The result is a pointer of the same type that is being added.  */
2552
2553   register tree result_type = TREE_TYPE (ptrop);
2554
2555   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2556     {
2557       if (pedantic || warn_pointer_arith)
2558         pedwarn ("pointer of type `void *' used in arithmetic");
2559       size_exp = integer_one_node;
2560     }
2561   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2562     {
2563       if (pedantic || warn_pointer_arith)
2564         pedwarn ("pointer to a function used in arithmetic");
2565       size_exp = integer_one_node;
2566     }
2567   else
2568     size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2569
2570   /* If what we are about to multiply by the size of the elements
2571      contains a constant term, apply distributive law
2572      and multiply that constant term separately.
2573      This helps produce common subexpressions.  */
2574
2575   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2576       && ! TREE_CONSTANT (intop)
2577       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2578       && TREE_CONSTANT (size_exp)
2579       /* If the constant comes from pointer subtraction,
2580          skip this optimization--it would cause an error.  */
2581       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2582       /* If the constant is unsigned, and smaller than the pointer size,
2583          then we must skip this optimization.  This is because it could cause
2584          an overflow error if the constant is negative but INTOP is not.  */
2585       && (! TREE_UNSIGNED (TREE_TYPE (intop))
2586           || (TYPE_PRECISION (TREE_TYPE (intop))
2587               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2588     {
2589       enum tree_code subcode = resultcode;
2590       tree int_type = TREE_TYPE (intop);
2591       if (TREE_CODE (intop) == MINUS_EXPR)
2592         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2593       /* Convert both subexpression types to the type of intop,
2594          because weird cases involving pointer arithmetic
2595          can result in a sum or difference with different type args.  */
2596       ptrop = build_binary_op (subcode, ptrop,
2597                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2598       intop = convert (int_type, TREE_OPERAND (intop, 0));
2599     }
2600
2601   /* Convert the integer argument to a type the same size as sizetype
2602      so the multiply won't overflow spuriously.  */
2603
2604   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2605       || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2606     intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2607                                     TREE_UNSIGNED (sizetype)), intop);
2608
2609   /* Replace the integer argument with a suitable product by the object size.
2610      Do this multiplication as signed, then convert to the appropriate
2611      pointer type (actually unsigned integral).  */
2612
2613   intop = convert (result_type,
2614                    build_binary_op (MULT_EXPR, intop,
2615                                     convert (TREE_TYPE (intop), size_exp), 1));
2616
2617   /* Create the sum or difference.  */
2618
2619   result = build (resultcode, result_type, ptrop, intop);
2620
2621   folded = fold (result);
2622   if (folded == result)
2623     TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2624   return folded;
2625 }
2626
2627 /* Return a tree for the difference of pointers OP0 and OP1.
2628    The resulting tree has type int.  */
2629
2630 static tree
2631 pointer_diff (op0, op1)
2632      register tree op0, op1;
2633 {
2634   register tree result, folded;
2635   tree restype = ptrdiff_type_node;
2636
2637   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2638
2639   if (pedantic || warn_pointer_arith)
2640     {
2641       if (TREE_CODE (target_type) == VOID_TYPE)
2642         pedwarn ("pointer of type `void *' used in subtraction");
2643       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2644         pedwarn ("pointer to a function used in subtraction");
2645     }
2646
2647   /* First do the subtraction as integers;
2648      then drop through to build the divide operator.
2649      Do not do default conversions on the minus operator
2650      in case restype is a short type.  */
2651
2652   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2653                          convert (restype, op1), 0);
2654   /* This generates an error if op1 is pointer to incomplete type.  */
2655   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
2656     error ("arithmetic on pointer to an incomplete type");
2657
2658   /* This generates an error if op0 is pointer to incomplete type.  */
2659   op1 = c_size_in_bytes (target_type);
2660
2661   /* Divide by the size, in easiest possible way.  */
2662
2663   result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2664
2665   folded = fold (result);
2666   if (folded == result)
2667     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2668   return folded;
2669 }
2670 \f
2671 /* Construct and perhaps optimize a tree representation
2672    for a unary operation.  CODE, a tree_code, specifies the operation
2673    and XARG is the operand.  NOCONVERT nonzero suppresses
2674    the default promotions (such as from short to int).  */
2675
2676 tree
2677 build_unary_op (code, xarg, noconvert)
2678      enum tree_code code;
2679      tree xarg;
2680      int noconvert;
2681 {
2682   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2683   register tree arg = xarg;
2684   register tree argtype = 0;
2685   register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2686   tree val;
2687
2688   if (typecode == ERROR_MARK)
2689     return error_mark_node;
2690   if (typecode == ENUMERAL_TYPE)
2691     typecode = INTEGER_TYPE;
2692
2693   switch (code)
2694     {
2695     case CONVERT_EXPR:
2696       /* This is used for unary plus, because a CONVERT_EXPR
2697          is enough to prevent anybody from looking inside for
2698          associativity, but won't generate any code.  */
2699       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2700             || typecode == COMPLEX_TYPE))
2701         {
2702           error ("wrong type argument to unary plus");
2703           return error_mark_node;
2704         }
2705       else if (!noconvert)
2706         arg = default_conversion (arg);
2707       break;
2708
2709     case NEGATE_EXPR:
2710       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2711             || typecode == COMPLEX_TYPE))
2712         {
2713           error ("wrong type argument to unary minus");
2714           return error_mark_node;
2715         }
2716       else if (!noconvert)
2717         arg = default_conversion (arg);
2718       break;
2719
2720     case BIT_NOT_EXPR:
2721       if (typecode == COMPLEX_TYPE)
2722         {
2723           code = CONJ_EXPR;
2724           if (!noconvert)
2725             arg = default_conversion (arg);
2726         }
2727       else if (typecode != INTEGER_TYPE)
2728         {
2729           error ("wrong type argument to bit-complement");
2730           return error_mark_node;
2731         }
2732       else if (!noconvert)
2733         arg = default_conversion (arg);
2734       break;
2735
2736     case ABS_EXPR:
2737       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2738             || typecode == COMPLEX_TYPE))
2739         {
2740           error ("wrong type argument to abs");
2741           return error_mark_node;
2742         }
2743       else if (!noconvert)
2744         arg = default_conversion (arg);
2745       break;
2746
2747     case CONJ_EXPR:
2748       /* Conjugating a real value is a no-op, but allow it anyway.  */
2749       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2750             || typecode == COMPLEX_TYPE))
2751         {
2752           error ("wrong type argument to conjugation");
2753           return error_mark_node;
2754         }
2755       else if (!noconvert)
2756         arg = default_conversion (arg);
2757       break;
2758
2759     case TRUTH_NOT_EXPR:
2760       if (typecode != INTEGER_TYPE
2761           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2762           && typecode != COMPLEX_TYPE
2763           /* These will convert to a pointer.  */
2764           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2765         {
2766           error ("wrong type argument to unary exclamation mark");
2767           return error_mark_node;
2768         }
2769       arg = truthvalue_conversion (arg);
2770       return invert_truthvalue (arg);
2771
2772     case NOP_EXPR:
2773       break;
2774
2775     case REALPART_EXPR:
2776       if (TREE_CODE (arg) == COMPLEX_CST)
2777         return TREE_REALPART (arg);
2778       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2779         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2780       else
2781         return arg;
2782
2783     case IMAGPART_EXPR:
2784       if (TREE_CODE (arg) == COMPLEX_CST)
2785         return TREE_IMAGPART (arg);
2786       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2787         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2788       else
2789         return convert (TREE_TYPE (arg), integer_zero_node);
2790
2791     case PREINCREMENT_EXPR:
2792     case POSTINCREMENT_EXPR:
2793     case PREDECREMENT_EXPR:
2794     case POSTDECREMENT_EXPR:
2795       /* Handle complex lvalues (when permitted)
2796          by reduction to simpler cases.  */
2797
2798       val = unary_complex_lvalue (code, arg);
2799       if (val != 0)
2800         return val;
2801
2802       /* Increment or decrement the real part of the value,
2803          and don't change the imaginary part.  */
2804       if (typecode == COMPLEX_TYPE)
2805         {
2806           tree real, imag;
2807
2808           arg = stabilize_reference (arg);
2809           real = build_unary_op (REALPART_EXPR, arg, 1);
2810           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2811           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2812                         build_unary_op (code, real, 1), imag);
2813         }
2814
2815       /* Report invalid types.  */
2816
2817       if (typecode != POINTER_TYPE
2818           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2819         {
2820           error ("wrong type argument to %s",
2821                  code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2822                  ? "increment" : "decrement");
2823           return error_mark_node;
2824         }
2825
2826       {
2827         register tree inc;
2828         tree result_type = TREE_TYPE (arg);
2829
2830         arg = get_unwidened (arg, 0);
2831         argtype = TREE_TYPE (arg);
2832
2833         /* Compute the increment.  */
2834
2835         if (typecode == POINTER_TYPE)
2836           {
2837             /* If pointer target is an undefined struct,
2838                we just cannot know how to do the arithmetic.  */
2839             if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
2840               error ("%s of pointer to unknown structure",
2841                      code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2842                      ? "increment" : "decrement");
2843             else if ((pedantic || warn_pointer_arith)
2844                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2845                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2846               pedwarn ("wrong type argument to %s",
2847                        code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2848                        ? "increment" : "decrement");
2849             inc = c_size_in_bytes (TREE_TYPE (result_type));
2850           }
2851         else
2852           inc = integer_one_node;
2853
2854         inc = convert (argtype, inc);
2855
2856         /* Handle incrementing a cast-expression.  */
2857
2858         while (1)
2859           switch (TREE_CODE (arg))
2860             {
2861             case NOP_EXPR:
2862             case CONVERT_EXPR:
2863             case FLOAT_EXPR:
2864             case FIX_TRUNC_EXPR:
2865             case FIX_FLOOR_EXPR:
2866             case FIX_ROUND_EXPR:
2867             case FIX_CEIL_EXPR:
2868               pedantic_lvalue_warning (CONVERT_EXPR);
2869               /* If the real type has the same machine representation
2870                  as the type it is cast to, we can make better output
2871                  by adding directly to the inside of the cast.  */
2872               if ((TREE_CODE (TREE_TYPE (arg))
2873                    == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2874                   && (TYPE_MODE (TREE_TYPE (arg))
2875                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2876                 arg = TREE_OPERAND (arg, 0);
2877               else
2878                 {
2879                   tree incremented, modify, value;
2880                   arg = stabilize_reference (arg);
2881                   if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2882                     value = arg;
2883                   else
2884                     value = save_expr (arg);
2885                   incremented = build (((code == PREINCREMENT_EXPR
2886                                          || code == POSTINCREMENT_EXPR)
2887                                         ? PLUS_EXPR : MINUS_EXPR),
2888                                        argtype, value, inc);
2889                   TREE_SIDE_EFFECTS (incremented) = 1;
2890                   modify = build_modify_expr (arg, NOP_EXPR, incremented);
2891                   value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2892                   TREE_USED (value) = 1;
2893                   return value;
2894                 }
2895               break;
2896
2897             default:
2898               goto give_up;
2899             }
2900       give_up:
2901
2902         /* Complain about anything else that is not a true lvalue.  */
2903         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2904                                     || code == POSTINCREMENT_EXPR)
2905                                    ? "invalid lvalue in increment"
2906                                    : "invalid lvalue in decrement")))
2907           return error_mark_node;
2908
2909         /* Report a read-only lvalue.  */
2910         if (TREE_READONLY (arg))
2911           readonly_warning (arg,
2912                             ((code == PREINCREMENT_EXPR
2913                               || code == POSTINCREMENT_EXPR)
2914                              ? "increment" : "decrement"));
2915
2916         val = build (code, TREE_TYPE (arg), arg, inc);
2917         TREE_SIDE_EFFECTS (val) = 1;
2918         val = convert (result_type, val);
2919         if (TREE_CODE (val) != code)
2920           TREE_NO_UNUSED_WARNING (val) = 1;
2921         return val;
2922       }
2923
2924     case ADDR_EXPR:
2925       /* Note that this operation never does default_conversion
2926          regardless of NOCONVERT.  */
2927
2928       /* Let &* cancel out to simplify resulting code.  */
2929       if (TREE_CODE (arg) == INDIRECT_REF)
2930         {
2931           /* Don't let this be an lvalue.  */
2932           if (lvalue_p (TREE_OPERAND (arg, 0)))
2933             return non_lvalue (TREE_OPERAND (arg, 0));
2934           return TREE_OPERAND (arg, 0);
2935         }
2936
2937       /* For &x[y], return x+y */
2938       if (TREE_CODE (arg) == ARRAY_REF)
2939         {
2940           if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
2941             return error_mark_node;
2942           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2943                                   TREE_OPERAND (arg, 1), 1);
2944         }
2945
2946       /* Handle complex lvalues (when permitted)
2947          by reduction to simpler cases.  */
2948       val = unary_complex_lvalue (code, arg);
2949       if (val != 0)
2950         return val;
2951
2952 #if 0 /* Turned off because inconsistent;
2953          float f; *&(int)f = 3.4 stores in int format
2954          whereas (int)f = 3.4 stores in float format.  */
2955       /* Address of a cast is just a cast of the address
2956          of the operand of the cast.  */
2957       switch (TREE_CODE (arg))
2958         {
2959         case NOP_EXPR:
2960         case CONVERT_EXPR:
2961         case FLOAT_EXPR:
2962         case FIX_TRUNC_EXPR:
2963         case FIX_FLOOR_EXPR:
2964         case FIX_ROUND_EXPR:
2965         case FIX_CEIL_EXPR:
2966           if (pedantic)
2967             pedwarn ("ANSI C forbids the address of a cast expression");
2968           return convert (build_pointer_type (TREE_TYPE (arg)),
2969                           build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
2970                                           0));
2971         }
2972 #endif
2973
2974       /* Allow the address of a constructor if all the elements
2975          are constant.  */
2976       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
2977         ;
2978       /* Anything not already handled and not a true memory reference
2979          is an error.  */
2980       else if (typecode != FUNCTION_TYPE
2981                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
2982         return error_mark_node;
2983
2984       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2985       argtype = TREE_TYPE (arg);
2986       /* If the lvalue is const or volatile, merge that into the type
2987          to which the address will point.  Note that you can't get a
2988          restricted pointer by taking the address of something, so we
2989          only have to deal with `const' and `volatile' here.  */
2990       if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
2991           || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
2992         {
2993           if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
2994             argtype = c_build_type_variant (argtype,
2995                                             TREE_READONLY (arg),
2996                                             TREE_THIS_VOLATILE (arg));
2997         }
2998
2999       argtype = build_pointer_type (argtype);
3000
3001       if (mark_addressable (arg) == 0)
3002         return error_mark_node;
3003
3004       {
3005         tree addr;
3006
3007         if (TREE_CODE (arg) == COMPONENT_REF)
3008           {
3009             tree field = TREE_OPERAND (arg, 1);
3010
3011             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3012
3013             if (DECL_C_BIT_FIELD (field))
3014               {
3015                 error ("attempt to take address of bit-field structure member `%s'",
3016                        IDENTIFIER_POINTER (DECL_NAME (field)));
3017                 return error_mark_node;
3018               }
3019
3020             addr = convert (argtype, addr);
3021
3022             if (! integer_zerop (DECL_FIELD_BITPOS (field)))
3023               {
3024                 tree offset
3025                   = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
3026                                 size_int (BITS_PER_UNIT));
3027                 int flag = TREE_CONSTANT (addr);
3028                 addr = fold (build (PLUS_EXPR, argtype,
3029                                     addr, convert (argtype, offset)));
3030                 TREE_CONSTANT (addr) = flag;
3031               }
3032           }
3033         else
3034           addr = build1 (code, argtype, arg);
3035
3036         /* Address of a static or external variable or
3037            file-scope function counts as a constant.  */
3038         if (staticp (arg)
3039             && ! (TREE_CODE (arg) == FUNCTION_DECL
3040                   && DECL_CONTEXT (arg) != 0))
3041           TREE_CONSTANT (addr) = 1;
3042         return addr;
3043       }
3044
3045     default:
3046       break;
3047     }
3048
3049   if (argtype == 0)
3050     argtype = TREE_TYPE (arg);
3051   return fold (build1 (code, argtype, arg));
3052 }
3053
3054 #if 0
3055 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3056    convert ARG with the same conversions in the same order
3057    and return the result.  */
3058
3059 static tree
3060 convert_sequence (conversions, arg)
3061      tree conversions;
3062      tree arg;
3063 {
3064   switch (TREE_CODE (conversions))
3065     {
3066     case NOP_EXPR:
3067     case CONVERT_EXPR:
3068     case FLOAT_EXPR:
3069     case FIX_TRUNC_EXPR:
3070     case FIX_FLOOR_EXPR:
3071     case FIX_ROUND_EXPR:
3072     case FIX_CEIL_EXPR:
3073       return convert (TREE_TYPE (conversions),
3074                       convert_sequence (TREE_OPERAND (conversions, 0),
3075                                         arg));
3076
3077     default:
3078       return arg;
3079     }
3080 }
3081 #endif /* 0 */
3082
3083 /* Return nonzero if REF is an lvalue valid for this language.
3084    Lvalues can be assigned, unless their type has TYPE_READONLY.
3085    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
3086
3087 int
3088 lvalue_p (ref)
3089      tree ref;
3090 {
3091   register enum tree_code code = TREE_CODE (ref);
3092
3093   switch (code)
3094     {
3095     case REALPART_EXPR:
3096     case IMAGPART_EXPR:
3097     case COMPONENT_REF:
3098       return lvalue_p (TREE_OPERAND (ref, 0));
3099
3100     case STRING_CST:
3101       return 1;
3102
3103     case INDIRECT_REF:
3104     case ARRAY_REF:
3105     case VAR_DECL:
3106     case PARM_DECL:
3107     case RESULT_DECL:
3108     case ERROR_MARK:
3109       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3110               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3111
3112     case BIND_EXPR:
3113     case RTL_EXPR:
3114       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3115
3116     default:
3117       return 0;
3118     }
3119 }
3120
3121 /* Return nonzero if REF is an lvalue valid for this language;
3122    otherwise, print an error message and return zero.  */
3123
3124 int
3125 lvalue_or_else (ref, msgid)
3126      tree ref;
3127      const char *msgid;
3128 {
3129   int win = lvalue_p (ref);
3130
3131   if (! win)
3132     error ("%s", msgid);
3133
3134   return win;
3135 }
3136
3137 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3138    for certain kinds of expressions which are not really lvalues
3139    but which we can accept as lvalues.
3140
3141    If ARG is not a kind of expression we can handle, return zero.  */
3142
3143 static tree
3144 unary_complex_lvalue (code, arg)
3145      enum tree_code code;
3146      tree arg;
3147 {
3148   /* Handle (a, b) used as an "lvalue".  */
3149   if (TREE_CODE (arg) == COMPOUND_EXPR)
3150     {
3151       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3152
3153       /* If this returns a function type, it isn't really being used as
3154          an lvalue, so don't issue a warning about it.  */
3155       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3156         pedantic_lvalue_warning (COMPOUND_EXPR);
3157
3158       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3159                     TREE_OPERAND (arg, 0), real_result);
3160     }
3161
3162   /* Handle (a ? b : c) used as an "lvalue".  */
3163   if (TREE_CODE (arg) == COND_EXPR)
3164     {
3165       pedantic_lvalue_warning (COND_EXPR);
3166       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3167         pedantic_lvalue_warning (COMPOUND_EXPR);
3168
3169       return (build_conditional_expr
3170               (TREE_OPERAND (arg, 0),
3171                build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3172                build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3173     }
3174
3175   return 0;
3176 }
3177
3178 /* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
3179    COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
3180
3181 static void
3182 pedantic_lvalue_warning (code)
3183      enum tree_code code;
3184 {
3185   if (pedantic)
3186     switch (code)
3187       {
3188       case COND_EXPR:
3189         pedwarn ("ANSI C forbids use of conditional expressions as lvalues");
3190         break;
3191       case COMPOUND_EXPR:
3192         pedwarn ("ANSI C forbids use of compound expressions as lvalues");
3193         break;
3194       default:
3195         pedwarn ("ANSI C forbids use of cast expressions as lvalues");
3196         break;
3197       }
3198 }
3199 \f
3200 /* Warn about storing in something that is `const'.  */
3201
3202 void
3203 readonly_warning (arg, msgid)
3204      tree arg;
3205      const char *msgid;
3206 {
3207   /* Forbid assignments to iterators.  */
3208   if (TREE_CODE (arg) == VAR_DECL && ITERATOR_P (arg))
3209     pedwarn ("%s of iterator `%s'",  _(msgid),
3210              IDENTIFIER_POINTER (DECL_NAME (arg)));
3211
3212   if (TREE_CODE (arg) == COMPONENT_REF)
3213     {
3214       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3215         readonly_warning (TREE_OPERAND (arg, 0), msgid);
3216       else
3217         pedwarn ("%s of read-only member `%s'", _(msgid),
3218                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3219     }
3220   else if (TREE_CODE (arg) == VAR_DECL)
3221     pedwarn ("%s of read-only variable `%s'", _(msgid),
3222              IDENTIFIER_POINTER (DECL_NAME (arg)));
3223   else
3224     pedwarn ("%s of read-only location", _(msgid));
3225 }
3226 \f
3227 /* Mark EXP saying that we need to be able to take the
3228    address of it; it should not be allocated in a register.
3229    Value is 1 if successful.  */
3230
3231 int
3232 mark_addressable (exp)
3233      tree exp;
3234 {
3235   register tree x = exp;
3236   while (1)
3237     switch (TREE_CODE (x))
3238       {
3239       case COMPONENT_REF:
3240         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3241           {
3242             error ("cannot take address of bitfield `%s'",
3243                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3244             return 0;
3245           }
3246
3247         /* ... fall through ...  */
3248
3249       case ADDR_EXPR:
3250       case ARRAY_REF:
3251       case REALPART_EXPR:
3252       case IMAGPART_EXPR:
3253         x = TREE_OPERAND (x, 0);
3254         break;
3255
3256       case CONSTRUCTOR:
3257         TREE_ADDRESSABLE (x) = 1;
3258         return 1;
3259
3260       case VAR_DECL:
3261       case CONST_DECL:
3262       case PARM_DECL:
3263       case RESULT_DECL:
3264         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3265             && DECL_NONLOCAL (x))
3266           {
3267             if (TREE_PUBLIC (x))
3268               {
3269                 error ("global register variable `%s' used in nested function",
3270                        IDENTIFIER_POINTER (DECL_NAME (x)));
3271                 return 0;
3272               }
3273             pedwarn ("register variable `%s' used in nested function",
3274                      IDENTIFIER_POINTER (DECL_NAME (x)));
3275           }
3276         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3277           {
3278             if (TREE_PUBLIC (x))
3279               {
3280                 error ("address of global register variable `%s' requested",
3281                        IDENTIFIER_POINTER (DECL_NAME (x)));
3282                 return 0;
3283               }
3284
3285             /* If we are making this addressable due to its having
3286                volatile components, give a different error message.  Also
3287                handle the case of an unnamed parameter by not trying
3288                to give the name.  */
3289
3290             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3291               {
3292                 error ("cannot put object with volatile field into register");
3293                 return 0;
3294               }
3295
3296             pedwarn ("address of register variable `%s' requested",
3297                      IDENTIFIER_POINTER (DECL_NAME (x)));
3298           }
3299         put_var_into_stack (x);
3300
3301         /* drops in */
3302       case FUNCTION_DECL:
3303         TREE_ADDRESSABLE (x) = 1;
3304 #if 0  /* poplevel deals with this now.  */
3305         if (DECL_CONTEXT (x) == 0)
3306           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3307 #endif
3308
3309       default:
3310         return 1;
3311     }
3312 }
3313 \f
3314 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3315
3316 tree
3317 build_conditional_expr (ifexp, op1, op2)
3318      tree ifexp, op1, op2;
3319 {
3320   register tree type1;
3321   register tree type2;
3322   register enum tree_code code1;
3323   register enum tree_code code2;
3324   register tree result_type = NULL;
3325   tree orig_op1 = op1, orig_op2 = op2;
3326
3327   ifexp = truthvalue_conversion (default_conversion (ifexp));
3328
3329 #if 0 /* Produces wrong result if within sizeof.  */
3330   /* Don't promote the operands separately if they promote
3331      the same way.  Return the unpromoted type and let the combined
3332      value get promoted if necessary.  */
3333
3334   if (TREE_TYPE (op1) == TREE_TYPE (op2)
3335       && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3336       && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3337       && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3338     {
3339       if (TREE_CODE (ifexp) == INTEGER_CST)
3340         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3341
3342       return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3343     }
3344 #endif
3345
3346   /* Promote both alternatives.  */
3347
3348   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3349     op1 = default_conversion (op1);
3350   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3351     op2 = default_conversion (op2);
3352
3353   if (TREE_CODE (ifexp) == ERROR_MARK
3354       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3355       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3356     return error_mark_node;
3357
3358   type1 = TREE_TYPE (op1);
3359   code1 = TREE_CODE (type1);
3360   type2 = TREE_TYPE (op2);
3361   code2 = TREE_CODE (type2);
3362
3363   /* Quickly detect the usual case where op1 and op2 have the same type
3364      after promotion.  */
3365   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3366     {
3367       if (type1 == type2)
3368         result_type = type1;
3369       else
3370         result_type = TYPE_MAIN_VARIANT (type1);
3371     }
3372   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
3373            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
3374     {
3375       result_type = common_type (type1, type2);
3376
3377       /* If -Wsign-compare, warn here if type1 and type2 have
3378          different signedness.  We'll promote the signed to unsigned
3379          and later code won't know it used to be different.
3380          Do this check on the original types, so that explicit casts
3381          will be considered, but default promotions won't.  */
3382       if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3383           && !skip_evaluation)
3384         {
3385           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3386           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3387
3388           if (unsigned_op1 ^ unsigned_op2)
3389             {
3390               /* Do not warn if the result type is signed, since the
3391                  signed type will only be chosen if it can represent
3392                  all the values of the unsigned type.  */
3393               if (! TREE_UNSIGNED (result_type))
3394                 /* OK */;
3395               /* Do not warn if the signed quantity is an unsuffixed
3396                  integer literal (or some static constant expression
3397                  involving such literals) and it is non-negative.  */
3398               else if ((unsigned_op2 && TREE_CODE (op1) == INTEGER_CST
3399                         && tree_int_cst_sgn (op1) >= 0)
3400                        || (unsigned_op1 && TREE_CODE (op2) == INTEGER_CST
3401                            && tree_int_cst_sgn (op2) >= 0))
3402                 /* OK */;
3403               else
3404                 warning ("signed and unsigned type in conditional expression");
3405             }
3406         }
3407     }
3408   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3409     {
3410       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3411         pedwarn ("ANSI C forbids conditional expr with only one void side");
3412       result_type = void_type_node;
3413     }
3414   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3415     {
3416       if (comp_target_types (type1, type2))
3417         result_type = common_type (type1, type2);
3418       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3419                && TREE_CODE (orig_op1) != NOP_EXPR)
3420         result_type = qualify_type (type2, type1);
3421       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3422                && TREE_CODE (orig_op2) != NOP_EXPR)
3423         result_type = qualify_type (type1, type2);
3424       else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
3425         {
3426           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3427             pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3428           result_type = qualify_type (type1, type2);
3429         }
3430       else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
3431         {
3432           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3433             pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3434           result_type = qualify_type (type2, type1);
3435         }
3436       else
3437         {
3438           pedwarn ("pointer type mismatch in conditional expression");
3439           result_type = build_pointer_type (void_type_node);
3440         }
3441     }
3442   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3443     {
3444       if (! integer_zerop (op2))
3445         pedwarn ("pointer/integer type mismatch in conditional expression");
3446       else
3447         {
3448           op2 = null_pointer_node;
3449 #if 0  /* The spec seems to say this is permitted.  */
3450           if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
3451             pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3452 #endif
3453         }
3454       result_type = type1;
3455     }
3456   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3457     {
3458       if (!integer_zerop (op1))
3459         pedwarn ("pointer/integer type mismatch in conditional expression");
3460       else
3461         {
3462           op1 = null_pointer_node;
3463 #if 0  /* The spec seems to say this is permitted.  */
3464           if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
3465             pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3466 #endif
3467         }
3468       result_type = type2;
3469     }
3470
3471   if (!result_type)
3472     {
3473       if (flag_cond_mismatch)
3474         result_type = void_type_node;
3475       else
3476         {
3477           error ("type mismatch in conditional expression");
3478           return error_mark_node;
3479         }
3480     }
3481
3482   /* Merge const and volatile flags of the incoming types.  */
3483   result_type
3484     = build_type_variant (result_type,
3485                           TREE_READONLY (op1) || TREE_READONLY (op2),
3486                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3487
3488   if (result_type != TREE_TYPE (op1))
3489     op1 = convert_and_check (result_type, op1);
3490   if (result_type != TREE_TYPE (op2))
3491     op2 = convert_and_check (result_type, op2);
3492
3493 #if 0
3494   if (code1 == RECORD_TYPE || code1 == UNION_TYPE)
3495     {
3496       result_type = TREE_TYPE (op1);
3497       if (TREE_CONSTANT (ifexp))
3498         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3499
3500       if (TYPE_MODE (result_type) == BLKmode)
3501         {
3502           register tree tempvar
3503             = build_decl (VAR_DECL, NULL_TREE, result_type);
3504           register tree xop1 = build_modify_expr (tempvar, op1);
3505           register tree xop2 = build_modify_expr (tempvar, op2);
3506           register tree result = fold (build (COND_EXPR, result_type,
3507                                               ifexp, xop1, xop2));
3508
3509           layout_decl (tempvar, TYPE_ALIGN (result_type));
3510           /* No way to handle variable-sized objects here.
3511              I fear that the entire handling of BLKmode conditional exprs
3512              needs to be redone.  */
3513           if (TREE_CODE (DECL_SIZE (tempvar)) != INTEGER_CST)
3514             abort ();
3515           DECL_RTL (tempvar)
3516             = assign_stack_local (DECL_MODE (tempvar),
3517                                   (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
3518                                    + BITS_PER_UNIT - 1)
3519                                   / BITS_PER_UNIT,
3520                                   0);
3521
3522           TREE_SIDE_EFFECTS (result)
3523             = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
3524               | TREE_SIDE_EFFECTS (op2);
3525           return build (COMPOUND_EXPR, result_type, result, tempvar);
3526         }
3527     }
3528 #endif /* 0 */
3529
3530   if (TREE_CODE (ifexp) == INTEGER_CST)
3531     return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3532
3533   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3534 }
3535 \f
3536 /* Given a list of expressions, return a compound expression
3537    that performs them all and returns the value of the last of them.  */
3538
3539 tree
3540 build_compound_expr (list)
3541      tree list;
3542 {
3543   return internal_build_compound_expr (list, TRUE);
3544 }
3545
3546 static tree
3547 internal_build_compound_expr (list, first_p)
3548      tree list;
3549      int first_p;
3550 {
3551   register tree rest;
3552
3553   if (TREE_CHAIN (list) == 0)
3554     {
3555 #if 0 /* If something inside inhibited lvalueness, we should not override.  */
3556       /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
3557
3558       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3559       if (TREE_CODE (list) == NON_LVALUE_EXPR)
3560         list = TREE_OPERAND (list, 0);
3561 #endif
3562
3563       /* Don't let (0, 0) be null pointer constant.  */
3564       if (!first_p && integer_zerop (TREE_VALUE (list)))
3565         return non_lvalue (TREE_VALUE (list));
3566       return TREE_VALUE (list);
3567     }
3568
3569   if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
3570     {
3571       /* Convert arrays to pointers when there really is a comma operator.  */
3572       if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
3573         TREE_VALUE (TREE_CHAIN (list))
3574           = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
3575     }
3576
3577   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3578
3579   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3580     {
3581       /* The left-hand operand of a comma expression is like an expression
3582          statement: with -W or -Wunused, we should warn if it doesn't have
3583          any side-effects, unless it was explicitly cast to (void).  */
3584       if ((extra_warnings || warn_unused)
3585            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3586                 && TREE_TYPE (TREE_VALUE (list)) == void_type_node))
3587         warning ("left-hand operand of comma expression has no effect");
3588
3589       /* When pedantic, a compound expression can be neither an lvalue
3590          nor an integer constant expression.  */
3591       if (! pedantic)
3592         return rest;
3593     }
3594
3595   /* With -Wunused, we should also warn if the left-hand operand does have
3596      side-effects, but computes a value which is not used.  For example, in
3597      `foo() + bar(), baz()' the result of the `+' operator is not used,
3598      so we should issue a warning.  */
3599   else if (warn_unused)
3600     warn_if_unused_value (TREE_VALUE (list));
3601
3602   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3603 }
3604
3605 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3606
3607 tree
3608 build_c_cast (type, expr)
3609      register tree type;
3610      tree expr;
3611 {
3612   register tree value = expr;
3613
3614   if (type == error_mark_node || expr == error_mark_node)
3615     return error_mark_node;
3616   type = TYPE_MAIN_VARIANT (type);
3617
3618 #if 0
3619   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3620   if (TREE_CODE (value) == NON_LVALUE_EXPR)
3621     value = TREE_OPERAND (value, 0);
3622 #endif
3623
3624   if (TREE_CODE (type) == ARRAY_TYPE)
3625     {
3626       error ("cast specifies array type");
3627       return error_mark_node;
3628     }
3629
3630   if (TREE_CODE (type) == FUNCTION_TYPE)
3631     {
3632       error ("cast specifies function type");
3633       return error_mark_node;
3634     }
3635
3636   if (type == TREE_TYPE (value))
3637     {
3638       if (pedantic)
3639         {
3640           if (TREE_CODE (type) == RECORD_TYPE
3641               || TREE_CODE (type) == UNION_TYPE)
3642             pedwarn ("ANSI C forbids casting nonscalar to the same type");
3643         }
3644     }
3645   else if (TREE_CODE (type) == UNION_TYPE)
3646     {
3647       tree field;
3648       if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3649           || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3650         value = default_conversion (value);
3651
3652       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3653         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3654                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3655           break;
3656
3657       if (field)
3658         {
3659           const char *name;
3660           tree t;
3661
3662           if (pedantic)
3663             pedwarn ("ANSI C forbids casts to union type");
3664           if (TYPE_NAME (type) != 0)
3665             {
3666               if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3667                 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3668               else
3669                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3670             }
3671           else
3672             name = "";
3673           t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3674                                         build_tree_list (field, value)),
3675                            0, 0);
3676           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3677           return t;
3678         }
3679       error ("cast to union type from type not present in union");
3680       return error_mark_node;
3681     }
3682   else
3683     {
3684       tree otype, ovalue;
3685
3686       /* If casting to void, avoid the error that would come
3687          from default_conversion in the case of a non-lvalue array.  */
3688       if (type == void_type_node)
3689         return build1 (CONVERT_EXPR, type, value);
3690
3691       /* Convert functions and arrays to pointers,
3692          but don't convert any other types.  */
3693       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3694           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3695         value = default_conversion (value);
3696       otype = TREE_TYPE (value);
3697
3698       /* Optionally warn about potentially worrisome casts.  */
3699
3700       if (warn_cast_qual
3701           && TREE_CODE (type) == POINTER_TYPE
3702           && TREE_CODE (otype) == POINTER_TYPE)
3703         {
3704           /* Go to the innermost object being pointed to.  */
3705           tree in_type = type;
3706           tree in_otype = otype;
3707
3708           while (TREE_CODE (in_type) == POINTER_TYPE)
3709             in_type = TREE_TYPE (in_type);
3710           while (TREE_CODE (in_otype) == POINTER_TYPE)
3711             in_otype = TREE_TYPE (in_otype);
3712
3713           if (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type))
3714             /* There are qualifiers present in IN_OTYPE that are not
3715                present in IN_TYPE.  */
3716             pedwarn ("cast discards qualifiers from pointer target type");
3717         }
3718
3719       /* Warn about possible alignment problems.  */
3720       if (STRICT_ALIGNMENT && warn_cast_align
3721           && TREE_CODE (type) == POINTER_TYPE
3722           && TREE_CODE (otype) == POINTER_TYPE
3723           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3724           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3725           /* Don't warn about opaque types, where the actual alignment
3726              restriction is unknown.  */
3727           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3728                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3729                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3730           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3731         warning ("cast increases required alignment of target type");
3732
3733       if (TREE_CODE (type) == INTEGER_TYPE
3734           && TREE_CODE (otype) == POINTER_TYPE
3735           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3736           && !TREE_CONSTANT (value))
3737         warning ("cast from pointer to integer of different size");
3738
3739       if (warn_bad_function_cast
3740           && TREE_CODE (value) == CALL_EXPR
3741           && TREE_CODE (type) != TREE_CODE (otype))
3742         warning ("cast does not match function type");
3743
3744       if (TREE_CODE (type) == POINTER_TYPE
3745           && TREE_CODE (otype) == INTEGER_TYPE
3746           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3747 #if 0
3748           /* Don't warn about converting 0 to pointer,
3749              provided the 0 was explicit--not cast or made by folding.  */
3750           && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
3751 #endif
3752           /* Don't warn about converting any constant.  */
3753           && !TREE_CONSTANT (value))
3754         warning ("cast to pointer from integer of different size");
3755
3756       ovalue = value;
3757       value = convert (type, value);
3758
3759       /* Ignore any integer overflow caused by the cast.  */
3760       if (TREE_CODE (value) == INTEGER_CST)
3761         {
3762           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3763           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3764         }
3765     }
3766
3767   /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant.  */
3768   if (pedantic && TREE_CODE (value) == INTEGER_CST
3769       && TREE_CODE (expr) == INTEGER_CST
3770       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3771     value = non_lvalue (value);
3772
3773   /* If pedantic, don't let a cast be an lvalue.  */
3774   if (value == expr && pedantic)
3775     value = non_lvalue (value);
3776
3777   return value;
3778 }
3779 \f
3780 /* Build an assignment expression of lvalue LHS from value RHS.
3781    MODIFYCODE is the code for a binary operator that we use
3782    to combine the old value of LHS with RHS to get the new value.
3783    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3784
3785 tree
3786 build_modify_expr (lhs, modifycode, rhs)
3787      tree lhs, rhs;
3788      enum tree_code modifycode;
3789 {
3790   register tree result;
3791   tree newrhs;
3792   tree lhstype = TREE_TYPE (lhs);
3793   tree olhstype = lhstype;
3794
3795   /* Types that aren't fully specified cannot be used in assignments.  */
3796   lhs = require_complete_type (lhs);
3797
3798   /* Avoid duplicate error messages from operands that had errors.  */
3799   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3800     return error_mark_node;
3801
3802   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3803   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3804      whose value is 0 to count as a null pointer constant.  */
3805   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3806     rhs = TREE_OPERAND (rhs, 0);
3807
3808   newrhs = rhs;
3809
3810   /* Handle control structure constructs used as "lvalues".  */
3811
3812   switch (TREE_CODE (lhs))
3813     {
3814       /* Handle (a, b) used as an "lvalue".  */
3815     case COMPOUND_EXPR:
3816       pedantic_lvalue_warning (COMPOUND_EXPR);
3817       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3818       if (TREE_CODE (newrhs) == ERROR_MARK)
3819         return error_mark_node;
3820       return build (COMPOUND_EXPR, lhstype,
3821                     TREE_OPERAND (lhs, 0), newrhs);
3822
3823       /* Handle (a ? b : c) used as an "lvalue".  */
3824     case COND_EXPR:
3825       pedantic_lvalue_warning (COND_EXPR);
3826       rhs = save_expr (rhs);
3827       {
3828         /* Produce (a ? (b = rhs) : (c = rhs))
3829            except that the RHS goes through a save-expr
3830            so the code to compute it is only emitted once.  */
3831         tree cond
3832           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3833                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3834                                                        modifycode, rhs),
3835                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3836                                                        modifycode, rhs));
3837         if (TREE_CODE (cond) == ERROR_MARK)
3838           return cond;
3839         /* Make sure the code to compute the rhs comes out
3840            before the split.  */
3841         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3842                       /* But cast it to void to avoid an "unused" error.  */
3843                       convert (void_type_node, rhs), cond);
3844       }
3845     default:
3846       break;
3847     }
3848
3849   /* If a binary op has been requested, combine the old LHS value with the RHS
3850      producing the value we should actually store into the LHS.  */
3851
3852   if (modifycode != NOP_EXPR)
3853     {
3854       lhs = stabilize_reference (lhs);
3855       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3856     }
3857
3858   /* Handle a cast used as an "lvalue".
3859      We have already performed any binary operator using the value as cast.
3860      Now convert the result to the cast type of the lhs,
3861      and then true type of the lhs and store it there;
3862      then convert result back to the cast type to be the value
3863      of the assignment.  */
3864
3865   switch (TREE_CODE (lhs))
3866     {
3867     case NOP_EXPR:
3868     case CONVERT_EXPR:
3869     case FLOAT_EXPR:
3870     case FIX_TRUNC_EXPR:
3871     case FIX_FLOOR_EXPR:
3872     case FIX_ROUND_EXPR:
3873     case FIX_CEIL_EXPR:
3874       if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3875           || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3876         newrhs = default_conversion (newrhs);
3877       {
3878         tree inner_lhs = TREE_OPERAND (lhs, 0);
3879         tree result;
3880         result = build_modify_expr (inner_lhs, NOP_EXPR,
3881                                     convert (TREE_TYPE (inner_lhs),
3882                                              convert (lhstype, newrhs)));
3883         if (TREE_CODE (result) == ERROR_MARK)
3884           return result;
3885         pedantic_lvalue_warning (CONVERT_EXPR);
3886         return convert (TREE_TYPE (lhs), result);
3887       }
3888
3889     default:
3890       break;
3891     }
3892
3893   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3894      Reject anything strange now.  */
3895
3896   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3897     return error_mark_node;
3898
3899   /* Warn about storing in something that is `const'.  */
3900
3901   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3902       || ((TREE_CODE (lhstype) == RECORD_TYPE
3903            || TREE_CODE (lhstype) == UNION_TYPE)
3904           && C_TYPE_FIELDS_READONLY (lhstype)))
3905     readonly_warning (lhs, "assignment");
3906
3907   /* If storing into a structure or union member,
3908      it has probably been given type `int'.
3909      Compute the type that would go with
3910      the actual amount of storage the member occupies.  */
3911
3912   if (TREE_CODE (lhs) == COMPONENT_REF
3913       && (TREE_CODE (lhstype) == INTEGER_TYPE
3914           || TREE_CODE (lhstype) == REAL_TYPE
3915           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3916     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3917
3918   /* If storing in a field that is in actuality a short or narrower than one,
3919      we must store in the field in its actual type.  */
3920
3921   if (lhstype != TREE_TYPE (lhs))
3922     {
3923       lhs = copy_node (lhs);
3924       TREE_TYPE (lhs) = lhstype;
3925     }
3926
3927   /* Convert new value to destination type.  */
3928
3929   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3930                                    NULL_TREE, NULL_TREE, 0);
3931   if (TREE_CODE (newrhs) == ERROR_MARK)
3932     return error_mark_node;
3933
3934   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3935   TREE_SIDE_EFFECTS (result) = 1;
3936
3937   /* If we got the LHS in a different type for storing in,
3938      convert the result back to the nominal type of LHS
3939      so that the value we return always has the same type
3940      as the LHS argument.  */
3941
3942   if (olhstype == TREE_TYPE (result))
3943     return result;
3944   return convert_for_assignment (olhstype, result, _("assignment"),
3945                                  NULL_TREE, NULL_TREE, 0);
3946 }
3947 \f
3948 /* Convert value RHS to type TYPE as preparation for an assignment
3949    to an lvalue of type TYPE.
3950    The real work of conversion is done by `convert'.
3951    The purpose of this function is to generate error messages
3952    for assignments that are not allowed in C.
3953    ERRTYPE is a string to use in error messages:
3954    "assignment", "return", etc.  If it is null, this is parameter passing
3955    for a function call (and different error messages are output).
3956
3957    FUNNAME is the name of the function being called,
3958    as an IDENTIFIER_NODE, or null.
3959    PARMNUM is the number of the argument, for printing in error messages.  */
3960
3961 static tree
3962 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
3963      tree type, rhs;
3964      const char *errtype;
3965      tree fundecl, funname;
3966      int parmnum;
3967 {
3968   register enum tree_code codel = TREE_CODE (type);
3969   register tree rhstype;
3970   register enum tree_code coder;
3971
3972   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3973   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3974      whose value is 0 to count as a null pointer constant.  */
3975   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3976     rhs = TREE_OPERAND (rhs, 0);
3977
3978   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3979       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3980     rhs = default_conversion (rhs);
3981   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3982     rhs = decl_constant_value (rhs);
3983
3984   rhstype = TREE_TYPE (rhs);
3985   coder = TREE_CODE (rhstype);
3986
3987   if (coder == ERROR_MARK)
3988     return error_mark_node;
3989
3990   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3991     {
3992       overflow_warning (rhs);
3993       /* Check for Objective-C protocols.  This will issue a warning if
3994          there are protocol violations.  No need to use the return value.  */
3995       maybe_objc_comptypes (type, rhstype, 0);
3996       return rhs;
3997     }
3998
3999   if (coder == VOID_TYPE)
4000     {
4001       error ("void value not ignored as it ought to be");
4002       return error_mark_node;
4003     }
4004   /* Arithmetic types all interconvert, and enum is treated like int.  */
4005   if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE
4006        || codel == COMPLEX_TYPE)
4007       && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE
4008           || coder == COMPLEX_TYPE))
4009     return convert_and_check (type, rhs);
4010
4011   /* Conversion to a transparent union from its member types.
4012      This applies only to function arguments.  */
4013   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4014     {
4015       tree memb_types;
4016       tree marginal_memb_type = 0;
4017
4018       for (memb_types = TYPE_FIELDS (type); memb_types;
4019            memb_types = TREE_CHAIN (memb_types))
4020         {
4021           tree memb_type = TREE_TYPE (memb_types);
4022
4023           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4024                          TYPE_MAIN_VARIANT (rhstype)))
4025             break;
4026
4027           if (TREE_CODE (memb_type) != POINTER_TYPE)
4028             continue;
4029
4030           if (coder == POINTER_TYPE)
4031             {
4032               register tree ttl = TREE_TYPE (memb_type);
4033               register tree ttr = TREE_TYPE (rhstype);
4034
4035               /* Any non-function converts to a [const][volatile] void *
4036                  and vice versa; otherwise, targets must be the same.
4037                  Meanwhile, the lhs target must have all the qualifiers of
4038                  the rhs.  */
4039               if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4040                   || TYPE_MAIN_VARIANT (ttr) == void_type_node
4041                   || comp_target_types (memb_type, rhstype))
4042                 {
4043                   /* If this type won't generate any warnings, use it.  */
4044                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4045                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4046                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4047                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4048                              == TYPE_QUALS (ttr))
4049                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4050                              == TYPE_QUALS (ttl))))
4051                     break;
4052
4053                   /* Keep looking for a better type, but remember this one.  */
4054                   if (! marginal_memb_type)
4055                     marginal_memb_type = memb_type;
4056                 }
4057             }
4058
4059           /* Can convert integer zero to any pointer type.  */
4060           if (integer_zerop (rhs)
4061               || (TREE_CODE (rhs) == NOP_EXPR
4062                   && integer_zerop (TREE_OPERAND (rhs, 0))))
4063             {
4064               rhs = null_pointer_node;
4065               break;
4066             }
4067         }
4068
4069       if (memb_types || marginal_memb_type)
4070         {
4071           if (! memb_types)
4072             {
4073               /* We have only a marginally acceptable member type;
4074                  it needs a warning.  */
4075               register tree ttl = TREE_TYPE (marginal_memb_type);
4076               register tree ttr = TREE_TYPE (rhstype);
4077
4078               /* Const and volatile mean something different for function
4079                  types, so the usual warnings are not appropriate.  */
4080               if (TREE_CODE (ttr) == FUNCTION_TYPE
4081                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4082                 {
4083                   /* Because const and volatile on functions are
4084                      restrictions that say the function will not do
4085                      certain things, it is okay to use a const or volatile
4086                      function where an ordinary one is wanted, but not
4087                      vice-versa.  */
4088                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4089                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
4090                                          errtype, funname, parmnum);
4091                 }
4092               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4093                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4094                                      errtype, funname,
4095                                      parmnum);
4096             }
4097
4098           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4099             pedwarn ("ANSI C prohibits argument conversion to union type");
4100
4101           return build1 (NOP_EXPR, type, rhs);
4102         }
4103     }
4104
4105   /* Conversions among pointers */
4106   else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
4107     {
4108       register tree ttl = TREE_TYPE (type);
4109       register tree ttr = TREE_TYPE (rhstype);
4110
4111       /* Any non-function converts to a [const][volatile] void *
4112          and vice versa; otherwise, targets must be the same.
4113          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4114       if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4115           || TYPE_MAIN_VARIANT (ttr) == void_type_node
4116           || comp_target_types (type, rhstype)
4117           || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4118               == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4119         {
4120           if (pedantic
4121               && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
4122                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4123                   ||
4124                   (TYPE_MAIN_VARIANT (ttr) == void_type_node
4125                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
4126                       which are not ANSI null ptr constants.  */
4127                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4128                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4129             warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
4130                                  errtype, funname, parmnum);
4131           /* Const and volatile mean something different for function types,
4132              so the usual warnings are not appropriate.  */
4133           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4134                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4135             {
4136               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4137                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4138                                      errtype, funname, parmnum);
4139               /* If this is not a case of ignoring a mismatch in signedness,
4140                  no warning.  */
4141               else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4142                        || TYPE_MAIN_VARIANT (ttr) == void_type_node
4143                        || comp_target_types (type, rhstype))
4144                 ;
4145               /* If there is a mismatch, do warn.  */
4146               else if (pedantic)
4147                 warn_for_assignment ("pointer targets in %s differ in signedness",
4148                                      errtype, funname, parmnum);
4149             }
4150           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4151                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4152             {
4153               /* Because const and volatile on functions are restrictions
4154                  that say the function will not do certain things,
4155                  it is okay to use a const or volatile function
4156                  where an ordinary one is wanted, but not vice-versa.  */
4157               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4158                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4159                                      errtype, funname, parmnum);
4160             }
4161         }
4162       else
4163         warn_for_assignment ("%s from incompatible pointer type",
4164                              errtype, funname, parmnum);
4165       return convert (type, rhs);
4166     }
4167   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4168     {
4169       /* An explicit constant 0 can convert to a pointer,
4170          or one that results from arithmetic, even including
4171          a cast to integer type.  */
4172       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4173           &&
4174           ! (TREE_CODE (rhs) == NOP_EXPR
4175              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4176              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4177              && integer_zerop (TREE_OPERAND (rhs, 0))))
4178         {
4179           warn_for_assignment ("%s makes pointer from integer without a cast",
4180                                errtype, funname, parmnum);
4181           return convert (type, rhs);
4182         }
4183       return null_pointer_node;
4184     }
4185   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4186     {
4187       warn_for_assignment ("%s makes integer from pointer without a cast",
4188                            errtype, funname, parmnum);
4189       return convert (type, rhs);
4190     }
4191
4192   if (!errtype)
4193     {
4194       if (funname)
4195         {
4196           tree selector = maybe_building_objc_message_expr ();
4197
4198           if (selector && parmnum > 2)
4199             error ("incompatible type for argument %d of `%s'",
4200                    parmnum - 2, IDENTIFIER_POINTER (selector));
4201           else
4202             error ("incompatible type for argument %d of `%s'",
4203                    parmnum, IDENTIFIER_POINTER (funname));
4204         }
4205       else
4206         error ("incompatible type for argument %d of indirect function call",
4207                parmnum);
4208     }
4209   else
4210     error ("incompatible types in %s", errtype);
4211
4212   return error_mark_node;
4213 }
4214
4215 /* Print a warning using MSGID.
4216    It gets OPNAME as its one parameter.
4217    If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4218    FUNCTION and ARGNUM are handled specially if we are building an
4219    Objective-C selector.  */
4220
4221 static void
4222 warn_for_assignment (msgid, opname, function, argnum)
4223      const char *msgid;
4224      const char *opname;
4225      tree function;
4226      int argnum;
4227 {
4228   if (opname == 0)
4229     {
4230       tree selector = maybe_building_objc_message_expr ();
4231       char * new_opname;
4232
4233       if (selector && argnum > 2)
4234         {
4235           function = selector;
4236           argnum -= 2;
4237         }
4238       if (function)
4239         {
4240           /* Function name is known; supply it.  */
4241           const char *argstring = _("passing arg %d of `%s'");
4242           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4243                                         + strlen (argstring) + 1 + 25
4244                                         /*%d*/ + 1);
4245           sprintf (new_opname, argstring, argnum,
4246                    IDENTIFIER_POINTER (function));
4247         }
4248       else
4249         {
4250           /* Function name unknown (call through ptr); just give arg number.*/
4251           const char *argnofun = _("passing arg %d of pointer to function");
4252           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4253           sprintf (new_opname, argnofun, argnum);
4254         }
4255       opname = new_opname;
4256     }
4257   pedwarn (msgid, opname);
4258 }
4259 \f
4260 /* If VALUE is a compound expr all of whose expressions are constant, then
4261    return its value.  Otherwise, return error_mark_node.
4262
4263    This is for handling COMPOUND_EXPRs as initializer elements
4264    which is allowed with a warning when -pedantic is specified.  */
4265
4266 static tree
4267 valid_compound_expr_initializer (value, endtype)
4268      tree value;
4269      tree endtype;
4270 {
4271   if (TREE_CODE (value) == COMPOUND_EXPR)
4272     {
4273       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4274           == error_mark_node)
4275         return error_mark_node;
4276       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4277                                               endtype);
4278     }
4279   else if (! TREE_CONSTANT (value)
4280            && ! initializer_constant_valid_p (value, endtype))
4281     return error_mark_node;
4282   else
4283     return value;
4284 }
4285 \f
4286 /* Perform appropriate conversions on the initial value of a variable,
4287    store it in the declaration DECL,
4288    and print any error messages that are appropriate.
4289    If the init is invalid, store an ERROR_MARK.  */
4290
4291 void
4292 store_init_value (decl, init)
4293      tree decl, init;
4294 {
4295   register tree value, type;
4296
4297   /* If variable's type was invalidly declared, just ignore it.  */
4298
4299   type = TREE_TYPE (decl);
4300   if (TREE_CODE (type) == ERROR_MARK)
4301     return;
4302
4303   /* Digest the specified initializer into an expression.  */
4304
4305   value = digest_init (type, init, TREE_STATIC (decl),
4306                        TREE_STATIC (decl) || pedantic);
4307
4308   /* Store the expression if valid; else report error.  */
4309
4310 #if 0
4311   /* Note that this is the only place we can detect the error
4312      in a case such as   struct foo bar = (struct foo) { x, y };
4313      where there is one initial value which is a constructor expression.  */
4314   if (value == error_mark_node)
4315     ;
4316   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4317     {
4318       error ("initializer for static variable is not constant");
4319       value = error_mark_node;
4320     }
4321   else if (TREE_STATIC (decl)
4322            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4323     {
4324       error ("initializer for static variable uses complicated arithmetic");
4325       value = error_mark_node;
4326     }
4327   else
4328     {
4329       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4330         {
4331           if (! TREE_CONSTANT (value))
4332             pedwarn ("aggregate initializer is not constant");
4333           else if (! TREE_STATIC (value))
4334             pedwarn ("aggregate initializer uses complicated arithmetic");
4335         }
4336     }
4337 #endif
4338
4339   DECL_INITIAL (decl) = value;
4340
4341   /* ANSI wants warnings about out-of-range constant initializers.  */
4342   STRIP_TYPE_NOPS (value);
4343   constant_expression_warning (value);
4344 }
4345 \f
4346 /* Methods for storing and printing names for error messages.  */
4347
4348 /* Implement a spelling stack that allows components of a name to be pushed
4349    and popped.  Each element on the stack is this structure.  */
4350
4351 struct spelling
4352 {
4353   int kind;
4354   union
4355     {
4356       int i;
4357       const char *s;
4358     } u;
4359 };
4360
4361 #define SPELLING_STRING 1
4362 #define SPELLING_MEMBER 2
4363 #define SPELLING_BOUNDS 3
4364
4365 static struct spelling *spelling;       /* Next stack element (unused).  */
4366 static struct spelling *spelling_base;  /* Spelling stack base.  */
4367 static int spelling_size;               /* Size of the spelling stack.  */
4368
4369 /* Macros to save and restore the spelling stack around push_... functions.
4370    Alternative to SAVE_SPELLING_STACK.  */
4371
4372 #define SPELLING_DEPTH() (spelling - spelling_base)
4373 #define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4374
4375 /* Save and restore the spelling stack around arbitrary C code.  */
4376
4377 #define SAVE_SPELLING_DEPTH(code)               \
4378 {                                               \
4379   int __depth = SPELLING_DEPTH ();              \
4380   code;                                         \
4381   RESTORE_SPELLING_DEPTH (__depth);             \
4382 }
4383
4384 /* Push an element on the spelling stack with type KIND and assign VALUE
4385    to MEMBER.  */
4386
4387 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4388 {                                                                       \
4389   int depth = SPELLING_DEPTH ();                                        \
4390                                                                         \
4391   if (depth >= spelling_size)                                           \
4392     {                                                                   \
4393       spelling_size += 10;                                              \
4394       if (spelling_base == 0)                                           \
4395         spelling_base                                                   \
4396           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4397       else                                                              \
4398         spelling_base                                                   \
4399           = (struct spelling *) xrealloc (spelling_base,                \
4400                                           spelling_size * sizeof (struct spelling));    \
4401       RESTORE_SPELLING_DEPTH (depth);                                   \
4402     }                                                                   \
4403                                                                         \
4404   spelling->kind = (KIND);                                              \
4405   spelling->MEMBER = (VALUE);                                           \
4406   spelling++;                                                           \
4407 }
4408
4409 /* Push STRING on the stack.  Printed literally.  */
4410
4411 static void
4412 push_string (string)
4413      const char *string;
4414 {
4415   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4416 }
4417
4418 /* Push a member name on the stack.  Printed as '.' STRING.  */
4419
4420 static void
4421 push_member_name (decl)
4422      tree decl;
4423
4424 {
4425   const char *string
4426     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4427   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4428 }
4429
4430 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4431
4432 static void
4433 push_array_bounds (bounds)
4434      int bounds;
4435 {
4436   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4437 }
4438
4439 /* Compute the maximum size in bytes of the printed spelling.  */
4440
4441 static int
4442 spelling_length ()
4443 {
4444   register int size = 0;
4445   register struct spelling *p;
4446
4447   for (p = spelling_base; p < spelling; p++)
4448     {
4449       if (p->kind == SPELLING_BOUNDS)
4450         size += 25;
4451       else
4452         size += strlen (p->u.s) + 1;
4453     }
4454
4455   return size;
4456 }
4457
4458 /* Print the spelling to BUFFER and return it.  */
4459
4460 static char *
4461 print_spelling (buffer)
4462      register char *buffer;
4463 {
4464   register char *d = buffer;
4465   register struct spelling *p;
4466
4467   for (p = spelling_base; p < spelling; p++)
4468     if (p->kind == SPELLING_BOUNDS)
4469       {
4470         sprintf (d, "[%d]", p->u.i);
4471         d += strlen (d);
4472       }
4473     else
4474       {
4475         register const char *s;
4476         if (p->kind == SPELLING_MEMBER)
4477           *d++ = '.';
4478         for (s = p->u.s; (*d = *s++); d++)
4479           ;
4480       }
4481   *d++ = '\0';
4482   return buffer;
4483 }
4484
4485 /* Issue an error message for a bad initializer component.
4486    MSGID identifies the message.
4487    The component name is taken from the spelling stack.  */
4488
4489 void
4490 error_init (msgid)
4491      const char *msgid;
4492 {
4493   char *ofwhat;
4494
4495   error ("%s", msgid);
4496   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4497   if (*ofwhat)
4498     error ("(near initialization for `%s')", ofwhat);
4499 }
4500
4501 /* Issue a pedantic warning for a bad initializer component.
4502    MSGID identifies the message.
4503    The component name is taken from the spelling stack.  */
4504
4505 void
4506 pedwarn_init (msgid)
4507      const char *msgid;
4508 {
4509   char *ofwhat;
4510
4511   pedwarn ("%s", msgid);
4512   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4513   if (*ofwhat)
4514     pedwarn ("(near initialization for `%s')", ofwhat);
4515 }
4516
4517 /* Issue a warning for a bad initializer component.
4518    MSGID identifies the message.
4519    The component name is taken from the spelling stack.  */
4520
4521 static void
4522 warning_init (msgid)
4523      const char *msgid;
4524 {
4525   char *ofwhat;
4526
4527   warning ("%s", msgid);
4528   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4529   if (*ofwhat)
4530     warning ("(near initialization for `%s')", ofwhat);
4531 }
4532 \f
4533 /* Digest the parser output INIT as an initializer for type TYPE.
4534    Return a C expression of type TYPE to represent the initial value.
4535
4536    The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4537    if non-constant initializers or elements are seen.  CONSTRUCTOR_CONSTANT
4538    applies only to elements of constructors.  */
4539
4540 static tree
4541 digest_init (type, init, require_constant, constructor_constant)
4542      tree type, init;
4543      int require_constant, constructor_constant;
4544 {
4545   enum tree_code code = TREE_CODE (type);
4546   tree inside_init = init;
4547
4548   if (type == error_mark_node || init == error_mark_node)
4549     return error_mark_node;
4550
4551   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4552   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4553      whose value is 0 to count as a null pointer constant.  */
4554   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4555     inside_init = TREE_OPERAND (init, 0);
4556
4557   /* Initialization of an array of chars from a string constant
4558      optionally enclosed in braces.  */
4559
4560   if (code == ARRAY_TYPE)
4561     {
4562       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4563       if ((typ1 == char_type_node
4564            || typ1 == signed_char_type_node
4565            || typ1 == unsigned_char_type_node
4566            || typ1 == unsigned_wchar_type_node
4567            || typ1 == signed_wchar_type_node)
4568           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4569         {
4570           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4571                          TYPE_MAIN_VARIANT (type)))
4572             return inside_init;
4573
4574           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4575                != char_type_node)
4576               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4577             {
4578               error_init ("char-array initialized from wide string");
4579               return error_mark_node;
4580             }
4581           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4582                == char_type_node)
4583               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4584             {
4585               error_init ("int-array initialized from non-wide string");
4586               return error_mark_node;
4587             }
4588
4589           TREE_TYPE (inside_init) = type;
4590           if (TYPE_DOMAIN (type) != 0
4591               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
4592             {
4593               register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
4594               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4595               /* Subtract 1 (or sizeof (wchar_t))
4596                  because it's ok to ignore the terminating null char
4597                  that is counted in the length of the constant.  */
4598               if (size < TREE_STRING_LENGTH (inside_init)
4599                   - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
4600                      ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
4601                      : 1))
4602                 pedwarn_init ("initializer-string for array of chars is too long");
4603             }
4604           return inside_init;
4605         }
4606     }
4607
4608   /* Any type can be initialized
4609      from an expression of the same type, optionally with braces.  */
4610
4611   if (inside_init && TREE_TYPE (inside_init) != 0
4612       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4613                      TYPE_MAIN_VARIANT (type))
4614           || (code == ARRAY_TYPE
4615               && comptypes (TREE_TYPE (inside_init), type))
4616           || (code == POINTER_TYPE
4617               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4618                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4619               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4620                             TREE_TYPE (type)))))
4621     {
4622       if (code == POINTER_TYPE
4623           && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4624               || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4625         inside_init = default_conversion (inside_init);
4626       else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4627                && TREE_CODE (inside_init) != CONSTRUCTOR)
4628         {
4629           error_init ("array initialized from non-constant array expression");
4630           return error_mark_node;
4631         }
4632
4633       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4634         inside_init = decl_constant_value (inside_init);
4635
4636       /* Compound expressions can only occur here if -pedantic or
4637          -pedantic-errors is specified.  In the later case, we always want
4638          an error.  In the former case, we simply want a warning.  */
4639       if (require_constant && pedantic
4640           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4641         {
4642           inside_init
4643             = valid_compound_expr_initializer (inside_init,
4644                                                TREE_TYPE (inside_init));
4645           if (inside_init == error_mark_node)
4646             error_init ("initializer element is not constant");
4647           else
4648             pedwarn_init ("initializer element is not constant");
4649           if (flag_pedantic_errors)
4650             inside_init = error_mark_node;
4651         }
4652       else if (require_constant && ! TREE_CONSTANT (inside_init))
4653         {
4654           error_init ("initializer element is not constant");
4655           inside_init = error_mark_node;
4656         }
4657       else if (require_constant
4658                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4659         {
4660           error_init ("initializer element is not computable at load time");
4661           inside_init = error_mark_node;
4662         }
4663
4664       return inside_init;
4665     }
4666
4667   /* Handle scalar types, including conversions.  */
4668
4669   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4670       || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4671     {
4672       /* Note that convert_for_assignment calls default_conversion
4673          for arrays and functions.  We must not call it in the
4674          case where inside_init is a null pointer constant.  */
4675       inside_init
4676         = convert_for_assignment (type, init, _("initialization"),
4677                                   NULL_TREE, NULL_TREE, 0);
4678
4679       if (require_constant && ! TREE_CONSTANT (inside_init))
4680         {
4681           error_init ("initializer element is not constant");
4682           inside_init = error_mark_node;
4683         }
4684       else if (require_constant
4685                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4686         {
4687           error_init ("initializer element is not computable at load time");
4688           inside_init = error_mark_node;
4689         }
4690
4691       return inside_init;
4692     }
4693
4694   /* Come here only for records and arrays.  */
4695
4696   if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4697     {
4698       error_init ("variable-sized object may not be initialized");
4699       return error_mark_node;
4700     }
4701
4702   /* Traditionally, you can write  struct foo x = 0;
4703      and it initializes the first element of x to 0.  */
4704   if (flag_traditional)
4705     {
4706       tree top = 0, prev = 0, otype = type;
4707       while (TREE_CODE (type) == RECORD_TYPE
4708              || TREE_CODE (type) == ARRAY_TYPE
4709              || TREE_CODE (type) == QUAL_UNION_TYPE
4710              || TREE_CODE (type) == UNION_TYPE)
4711         {
4712           tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4713           if (prev == 0)
4714             top = temp;
4715           else
4716             TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4717           prev = temp;
4718           if (TREE_CODE (type) == ARRAY_TYPE)
4719             type = TREE_TYPE (type);
4720           else if (TYPE_FIELDS (type))
4721             type = TREE_TYPE (TYPE_FIELDS (type));
4722           else
4723             {
4724               error_init ("invalid initializer");
4725               return error_mark_node;
4726             }
4727         }
4728
4729       if (otype != type)
4730         {
4731           TREE_OPERAND (prev, 1)
4732             = build_tree_list (NULL_TREE,
4733                                digest_init (type, init, require_constant,
4734                                             constructor_constant));
4735           return top;
4736         }
4737       else
4738         return error_mark_node;
4739     }
4740   error_init ("invalid initializer");
4741   return error_mark_node;
4742 }
4743 \f
4744 /* Handle initializers that use braces.  */
4745
4746 /* Type of object we are accumulating a constructor for.
4747    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4748 static tree constructor_type;
4749
4750 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4751    left to fill.  */
4752 static tree constructor_fields;
4753
4754 /* For an ARRAY_TYPE, this is the specified index
4755    at which to store the next element we get.
4756    This is a special INTEGER_CST node that we modify in place.  */
4757 static tree constructor_index;
4758
4759 /* For an ARRAY_TYPE, this is the end index of the range
4760    to initialize with the next element, or NULL in the ordinary case
4761    where the element is used just once.  */
4762 static tree constructor_range_end;
4763
4764 /* For an ARRAY_TYPE, this is the maximum index.  */
4765 static tree constructor_max_index;
4766
4767 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4768 static tree constructor_unfilled_fields;
4769
4770 /* For an ARRAY_TYPE, this is the index of the first element
4771    not yet written out.
4772    This is a special INTEGER_CST node that we modify in place.  */
4773 static tree constructor_unfilled_index;
4774
4775 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4776    This is so we can generate gaps between fields, when appropriate.
4777    This is a special INTEGER_CST node that we modify in place.  */
4778 static tree constructor_bit_index;
4779
4780 /* If we are saving up the elements rather than allocating them,
4781    this is the list of elements so far (in reverse order,
4782    most recent first).  */
4783 static tree constructor_elements;
4784
4785 /* 1 if so far this constructor's elements are all compile-time constants.  */
4786 static int constructor_constant;
4787
4788 /* 1 if so far this constructor's elements are all valid address constants.  */
4789 static int constructor_simple;
4790
4791 /* 1 if this constructor is erroneous so far.  */
4792 static int constructor_erroneous;
4793
4794 /* 1 if have called defer_addressed_constants.  */
4795 static int constructor_subconstants_deferred;
4796
4797 /* Structure for managing pending initializer elements, organized as an
4798    AVL tree.  */
4799
4800 struct init_node
4801 {
4802   struct init_node *left, *right;
4803   struct init_node *parent;
4804   int balance;
4805   tree purpose;
4806   tree value;
4807 };
4808
4809 /* Tree of pending elements at this constructor level.
4810    These are elements encountered out of order
4811    which belong at places we haven't reached yet in actually
4812    writing the output.  */
4813 static struct init_node *constructor_pending_elts;
4814
4815 /* The SPELLING_DEPTH of this constructor.  */
4816 static int constructor_depth;
4817
4818 /* 0 if implicitly pushing constructor levels is allowed.  */
4819 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4820
4821 static int require_constant_value;
4822 static int require_constant_elements;
4823
4824 /* 1 if it is ok to output this constructor as we read it.
4825    0 means must accumulate a CONSTRUCTOR expression.  */
4826 static int constructor_incremental;
4827
4828 /* DECL node for which an initializer is being read.
4829    0 means we are reading a constructor expression
4830    such as (struct foo) {...}.  */
4831 static tree constructor_decl;
4832
4833 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4834 static char *constructor_asmspec;
4835
4836 /* Nonzero if this is an initializer for a top-level decl.  */
4837 static int constructor_top_level;
4838
4839 \f
4840 /* This stack has a level for each implicit or explicit level of
4841    structuring in the initializer, including the outermost one.  It
4842    saves the values of most of the variables above.  */
4843
4844 struct constructor_stack
4845 {
4846   struct constructor_stack *next;
4847   tree type;
4848   tree fields;
4849   tree index;
4850   tree range_end;
4851   tree max_index;
4852   tree unfilled_index;
4853   tree unfilled_fields;
4854   tree bit_index;
4855   tree elements;
4856   int offset;
4857   struct init_node *pending_elts;
4858   int depth;
4859   /* If nonzero, this value should replace the entire
4860      constructor at this level.  */
4861   tree replacement_value;
4862   char constant;
4863   char simple;
4864   char implicit;
4865   char incremental;
4866   char erroneous;
4867   char outer;
4868 };
4869
4870 struct constructor_stack *constructor_stack;
4871
4872 /* This stack records separate initializers that are nested.
4873    Nested initializers can't happen in ANSI C, but GNU C allows them
4874    in cases like { ... (struct foo) { ... } ... }.  */
4875
4876 struct initializer_stack
4877 {
4878   struct initializer_stack *next;
4879   tree decl;
4880   char *asmspec;
4881   struct constructor_stack *constructor_stack;
4882   tree elements;
4883   struct spelling *spelling;
4884   struct spelling *spelling_base;
4885   int spelling_size;
4886   char top_level;
4887   char incremental;
4888   char require_constant_value;
4889   char require_constant_elements;
4890   char deferred;
4891 };
4892
4893 struct initializer_stack *initializer_stack;
4894 \f
4895 /* Prepare to parse and output the initializer for variable DECL.  */
4896
4897 void
4898 start_init (decl, asmspec_tree, top_level)
4899      tree decl;
4900      tree asmspec_tree;
4901      int top_level;
4902 {
4903   const char *locus;
4904   struct initializer_stack *p
4905     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
4906   char *asmspec = 0;
4907
4908   if (asmspec_tree)
4909     asmspec = TREE_STRING_POINTER (asmspec_tree);
4910
4911   p->decl = constructor_decl;
4912   p->asmspec = constructor_asmspec;
4913   p->incremental = constructor_incremental;
4914   p->require_constant_value = require_constant_value;
4915   p->require_constant_elements = require_constant_elements;
4916   p->constructor_stack = constructor_stack;
4917   p->elements = constructor_elements;
4918   p->spelling = spelling;
4919   p->spelling_base = spelling_base;
4920   p->spelling_size = spelling_size;
4921   p->deferred = constructor_subconstants_deferred;
4922   p->top_level = constructor_top_level;
4923   p->next = initializer_stack;
4924   initializer_stack = p;
4925
4926   constructor_decl = decl;
4927   constructor_incremental = top_level;
4928   constructor_asmspec = asmspec;
4929   constructor_subconstants_deferred = 0;
4930   constructor_top_level = top_level;
4931
4932   if (decl != 0)
4933     {
4934       require_constant_value = TREE_STATIC (decl);
4935       require_constant_elements
4936         = ((TREE_STATIC (decl) || pedantic)
4937            /* For a scalar, you can always use any value to initialize,
4938               even within braces.  */
4939            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4940                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4941                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4942                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4943       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4944       constructor_incremental |= TREE_STATIC (decl);
4945     }
4946   else
4947     {
4948       require_constant_value = 0;
4949       require_constant_elements = 0;
4950       locus = "(anonymous)";
4951     }
4952
4953   constructor_stack = 0;
4954
4955   missing_braces_mentioned = 0;
4956
4957   spelling_base = 0;
4958   spelling_size = 0;
4959   RESTORE_SPELLING_DEPTH (0);
4960
4961   if (locus)
4962     push_string (locus);
4963 }
4964
4965 void
4966 finish_init ()
4967 {
4968   struct initializer_stack *p = initializer_stack;
4969
4970   /* Output subconstants (string constants, usually)
4971      that were referenced within this initializer and saved up.
4972      Must do this if and only if we called defer_addressed_constants.  */
4973   if (constructor_subconstants_deferred)
4974     output_deferred_addressed_constants ();
4975
4976   /* Free the whole constructor stack of this initializer.  */
4977   while (constructor_stack)
4978     {
4979       struct constructor_stack *q = constructor_stack;
4980       constructor_stack = q->next;
4981       free (q);
4982     }
4983
4984   /* Pop back to the data of the outer initializer (if any).  */
4985   constructor_decl = p->decl;
4986   constructor_asmspec = p->asmspec;
4987   constructor_incremental = p->incremental;
4988   require_constant_value = p->require_constant_value;
4989   require_constant_elements = p->require_constant_elements;
4990   constructor_stack = p->constructor_stack;
4991   constructor_elements = p->elements;
4992   spelling = p->spelling;
4993   spelling_base = p->spelling_base;
4994   spelling_size = p->spelling_size;
4995   constructor_subconstants_deferred = p->deferred;
4996   constructor_top_level = p->top_level;
4997   initializer_stack = p->next;
4998   free (p);
4999 }
5000 \f
5001 /* Call here when we see the initializer is surrounded by braces.
5002    This is instead of a call to push_init_level;
5003    it is matched by a call to pop_init_level.
5004
5005    TYPE is the type to initialize, for a constructor expression.
5006    For an initializer for a decl, TYPE is zero.  */
5007
5008 void
5009 really_start_incremental_init (type)
5010      tree type;
5011 {
5012   struct constructor_stack *p
5013     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5014
5015   if (type == 0)
5016     type = TREE_TYPE (constructor_decl);
5017
5018   /* Turn off constructor_incremental if type is a struct with bitfields.
5019      Do this before the first push, so that the corrected value
5020      is available in finish_init.  */
5021   check_init_type_bitfields (type);
5022
5023   p->type = constructor_type;
5024   p->fields = constructor_fields;
5025   p->index = constructor_index;
5026   p->range_end = constructor_range_end;
5027   p->max_index = constructor_max_index;
5028   p->unfilled_index = constructor_unfilled_index;
5029   p->unfilled_fields = constructor_unfilled_fields;
5030   p->bit_index = constructor_bit_index;
5031   p->elements = constructor_elements;
5032   p->constant = constructor_constant;
5033   p->simple = constructor_simple;
5034   p->erroneous = constructor_erroneous;
5035   p->pending_elts = constructor_pending_elts;
5036   p->depth = constructor_depth;
5037   p->replacement_value = 0;
5038   p->implicit = 0;
5039   p->incremental = constructor_incremental;
5040   p->outer = 0;
5041   p->next = 0;
5042   constructor_stack = p;
5043
5044   constructor_constant = 1;
5045   constructor_simple = 1;
5046   constructor_depth = SPELLING_DEPTH ();
5047   constructor_elements = 0;
5048   constructor_pending_elts = 0;
5049   constructor_type = type;
5050
5051   if (TREE_CODE (constructor_type) == RECORD_TYPE
5052       || TREE_CODE (constructor_type) == UNION_TYPE)
5053     {
5054       constructor_fields = TYPE_FIELDS (constructor_type);
5055       /* Skip any nameless bit fields at the beginning.  */
5056       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5057              && DECL_NAME (constructor_fields) == 0)
5058         constructor_fields = TREE_CHAIN (constructor_fields);
5059       constructor_unfilled_fields = constructor_fields;
5060       constructor_bit_index = copy_node (integer_zero_node);
5061       TREE_TYPE (constructor_bit_index) = sbitsizetype;
5062     }
5063   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5064     {
5065       constructor_range_end = 0;
5066       if (TYPE_DOMAIN (constructor_type))
5067         {
5068           constructor_max_index
5069             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5070           constructor_index
5071             = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5072         }
5073       else
5074         constructor_index = copy_node (integer_zero_node);
5075       constructor_unfilled_index = copy_node (constructor_index);
5076     }
5077   else
5078     {
5079       /* Handle the case of int x = {5}; */
5080       constructor_fields = constructor_type;
5081       constructor_unfilled_fields = constructor_type;
5082     }
5083
5084   if (constructor_incremental)
5085     {
5086       int momentary = suspend_momentary ();
5087       push_obstacks_nochange ();
5088       if (TREE_PERMANENT (constructor_decl))
5089         end_temporary_allocation ();
5090       make_decl_rtl (constructor_decl, constructor_asmspec,
5091                      constructor_top_level);
5092       assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5093       pop_obstacks ();
5094       resume_momentary (momentary);
5095     }
5096
5097   if (constructor_incremental)
5098     {
5099       defer_addressed_constants ();
5100       constructor_subconstants_deferred = 1;
5101     }
5102 }
5103 \f
5104 /* Push down into a subobject, for initialization.
5105    If this is for an explicit set of braces, IMPLICIT is 0.
5106    If it is because the next element belongs at a lower level,
5107    IMPLICIT is 1.  */
5108
5109 void
5110 push_init_level (implicit)
5111      int implicit;
5112 {
5113   struct constructor_stack *p;
5114
5115   /* If we've exhausted any levels that didn't have braces,
5116      pop them now.  */
5117   while (constructor_stack->implicit)
5118     {
5119       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5120            || TREE_CODE (constructor_type) == UNION_TYPE)
5121           && constructor_fields == 0)
5122         process_init_element (pop_init_level (1));
5123       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5124                && tree_int_cst_lt (constructor_max_index, constructor_index))
5125         process_init_element (pop_init_level (1));
5126       else
5127         break;
5128     }
5129
5130   /* Structure elements may require alignment.  Do this now if necessary
5131      for the subaggregate, and if it comes next in sequence.  Don't do
5132      this for subaggregates that will go on the pending list.  */
5133   if (constructor_incremental && constructor_type != 0
5134       && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
5135       && constructor_fields == constructor_unfilled_fields)
5136     {
5137       /* Advance to offset of this element.  */
5138       if (! tree_int_cst_equal (constructor_bit_index,
5139                                 DECL_FIELD_BITPOS (constructor_fields)))
5140         {
5141           /* By using unsigned arithmetic, the result will be correct even
5142              in case of overflows, if BITS_PER_UNIT is a power of two.  */
5143           unsigned next = (TREE_INT_CST_LOW
5144                            (DECL_FIELD_BITPOS (constructor_fields))
5145                            / (unsigned)BITS_PER_UNIT);
5146           unsigned here = (TREE_INT_CST_LOW (constructor_bit_index)
5147                            / (unsigned)BITS_PER_UNIT);
5148
5149           assemble_zeros ((next - here)
5150                           * (unsigned)BITS_PER_UNIT
5151                           / (unsigned)BITS_PER_UNIT);
5152         }
5153       /* Indicate that we have now filled the structure up to the current
5154          field.  */
5155       constructor_unfilled_fields = constructor_fields;
5156     }
5157
5158   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5159   p->type = constructor_type;
5160   p->fields = constructor_fields;
5161   p->index = constructor_index;
5162   p->range_end = constructor_range_end;
5163   p->max_index = constructor_max_index;
5164   p->unfilled_index = constructor_unfilled_index;
5165   p->unfilled_fields = constructor_unfilled_fields;
5166   p->bit_index = constructor_bit_index;
5167   p->elements = constructor_elements;
5168   p->constant = constructor_constant;
5169   p->simple = constructor_simple;
5170   p->erroneous = constructor_erroneous;
5171   p->pending_elts = constructor_pending_elts;
5172   p->depth = constructor_depth;
5173   p->replacement_value = 0;
5174   p->implicit = implicit;
5175   p->incremental = constructor_incremental;
5176   p->outer = 0;
5177   p->next = constructor_stack;
5178   constructor_stack = p;
5179
5180   constructor_constant = 1;
5181   constructor_simple = 1;
5182   constructor_depth = SPELLING_DEPTH ();
5183   constructor_elements = 0;
5184   constructor_pending_elts = 0;
5185
5186   /* Don't die if an entire brace-pair level is superfluous
5187      in the containing level.  */
5188   if (constructor_type == 0)
5189     ;
5190   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5191            || TREE_CODE (constructor_type) == UNION_TYPE)
5192     {
5193       /* Don't die if there are extra init elts at the end.  */
5194       if (constructor_fields == 0)
5195         constructor_type = 0;
5196       else
5197         {
5198           constructor_type = TREE_TYPE (constructor_fields);
5199           push_member_name (constructor_fields);
5200           constructor_depth++;
5201           if (constructor_fields != constructor_unfilled_fields)
5202             constructor_incremental = 0;
5203         }
5204     }
5205   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5206     {
5207       constructor_type = TREE_TYPE (constructor_type);
5208       push_array_bounds (TREE_INT_CST_LOW (constructor_index));
5209       constructor_depth++;
5210       if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5211           || constructor_range_end != 0)
5212         constructor_incremental = 0;
5213     }
5214
5215   if (constructor_type == 0)
5216     {
5217       error_init ("extra brace group at end of initializer");
5218       constructor_fields = 0;
5219       constructor_unfilled_fields = 0;
5220       return;
5221     }
5222
5223   /* Turn off constructor_incremental if type is a struct with bitfields.  */
5224   check_init_type_bitfields (constructor_type);
5225
5226   if (implicit && warn_missing_braces && !missing_braces_mentioned)
5227     {
5228       missing_braces_mentioned = 1;
5229       warning_init ("missing braces around initializer");
5230     }
5231
5232   if (TREE_CODE (constructor_type) == RECORD_TYPE
5233            || TREE_CODE (constructor_type) == UNION_TYPE)
5234     {
5235       constructor_fields = TYPE_FIELDS (constructor_type);
5236       /* Skip any nameless bit fields at the beginning.  */
5237       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5238              && DECL_NAME (constructor_fields) == 0)
5239         constructor_fields = TREE_CHAIN (constructor_fields);
5240       constructor_unfilled_fields = constructor_fields;
5241       constructor_bit_index = copy_node (integer_zero_node);
5242       TREE_TYPE (constructor_bit_index) = sbitsizetype;
5243     }
5244   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5245     {
5246       constructor_range_end = 0;
5247       if (TYPE_DOMAIN (constructor_type))
5248         {
5249           constructor_max_index
5250             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5251           constructor_index
5252             = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5253         }
5254       else
5255         constructor_index = copy_node (integer_zero_node);
5256       constructor_unfilled_index = copy_node (constructor_index);
5257     }
5258   else
5259     {
5260       warning_init ("braces around scalar initializer");
5261       constructor_fields = constructor_type;
5262       constructor_unfilled_fields = constructor_type;
5263     }
5264 }
5265
5266 /* Don't read a struct incrementally if it has any bitfields,
5267    because the incremental reading code doesn't know how to
5268    handle bitfields yet.  */
5269
5270 static void
5271 check_init_type_bitfields (type)
5272      tree type;
5273 {
5274   if (TREE_CODE (type) == RECORD_TYPE)
5275     {
5276       tree tail;
5277       for (tail = TYPE_FIELDS (type); tail;
5278            tail = TREE_CHAIN (tail))
5279         {
5280           if (DECL_C_BIT_FIELD (tail))
5281             {
5282               constructor_incremental = 0;
5283               break;
5284             }
5285
5286           check_init_type_bitfields (TREE_TYPE (tail));
5287         }
5288     }
5289
5290   else if (TREE_CODE (type) == UNION_TYPE)
5291     {
5292       tree tail = TYPE_FIELDS (type);
5293       if (tail && DECL_C_BIT_FIELD (tail))
5294         /* We also use the nonincremental algorithm for initiliazation
5295            of unions whose first member is a bitfield, becuase the
5296            incremental algorithm has no code for dealing with
5297            bitfields. */
5298         constructor_incremental = 0;
5299     }
5300
5301   else if (TREE_CODE (type) == ARRAY_TYPE)
5302     check_init_type_bitfields (TREE_TYPE (type));
5303 }
5304
5305 /* At the end of an implicit or explicit brace level,
5306    finish up that level of constructor.
5307    If we were outputting the elements as they are read, return 0
5308    from inner levels (process_init_element ignores that),
5309    but return error_mark_node from the outermost level
5310    (that's what we want to put in DECL_INITIAL).
5311    Otherwise, return a CONSTRUCTOR expression.  */
5312
5313 tree
5314 pop_init_level (implicit)
5315      int implicit;
5316 {
5317   struct constructor_stack *p;
5318   int size = 0;
5319   tree constructor = 0;
5320
5321   if (implicit == 0)
5322     {
5323       /* When we come to an explicit close brace,
5324          pop any inner levels that didn't have explicit braces.  */
5325       while (constructor_stack->implicit)
5326         process_init_element (pop_init_level (1));
5327     }
5328
5329   p = constructor_stack;
5330
5331   if (constructor_type != 0)
5332     size = int_size_in_bytes (constructor_type);
5333
5334   /* Warn when some struct elements are implicitly initialized to zero.  */
5335   if (extra_warnings
5336       && constructor_type
5337       && TREE_CODE (constructor_type) == RECORD_TYPE
5338       && constructor_unfilled_fields)
5339     {
5340       push_member_name (constructor_unfilled_fields);
5341       warning_init ("missing initializer");
5342       RESTORE_SPELLING_DEPTH (constructor_depth);
5343     }
5344
5345   /* Now output all pending elements.  */
5346   output_pending_init_elements (1);
5347
5348 #if 0 /* c-parse.in warns about {}.  */
5349   /* In ANSI, each brace level must have at least one element.  */
5350   if (! implicit && pedantic
5351       && (TREE_CODE (constructor_type) == ARRAY_TYPE
5352           ? integer_zerop (constructor_unfilled_index)
5353           : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
5354     pedwarn_init ("empty braces in initializer");
5355 #endif
5356
5357   /* Pad out the end of the structure.  */
5358
5359   if (p->replacement_value)
5360     {
5361       /* If this closes a superfluous brace pair,
5362          just pass out the element between them.  */
5363       constructor = p->replacement_value;
5364       /* If this is the top level thing within the initializer,
5365          and it's for a variable, then since we already called
5366          assemble_variable, we must output the value now.  */
5367       if (p->next == 0 && constructor_decl != 0
5368           && constructor_incremental)
5369         {
5370           constructor = digest_init (constructor_type, constructor,
5371                                      require_constant_value,
5372                                      require_constant_elements);
5373
5374           /* If initializing an array of unknown size,
5375              determine the size now.  */
5376           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5377               && TYPE_DOMAIN (constructor_type) == 0)
5378             {
5379               int failure;
5380               int momentary_p;
5381
5382               push_obstacks_nochange ();
5383               if (TREE_PERMANENT (constructor_type))
5384                 end_temporary_allocation ();
5385
5386               momentary_p = suspend_momentary ();
5387
5388               /* We shouldn't have an incomplete array type within
5389                  some other type.  */
5390               if (constructor_stack->next)
5391                 abort ();
5392
5393               failure
5394                 = complete_array_type (constructor_type,
5395                                        constructor, 0);
5396               if (failure)
5397                 abort ();
5398
5399               size = int_size_in_bytes (constructor_type);
5400               resume_momentary (momentary_p);
5401               pop_obstacks ();
5402             }
5403
5404           output_constant (constructor, size);
5405         }
5406     }
5407   else if (constructor_type == 0)
5408     ;
5409   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5410            && TREE_CODE (constructor_type) != UNION_TYPE
5411            && TREE_CODE (constructor_type) != ARRAY_TYPE
5412            && ! constructor_incremental)
5413     {
5414       /* A nonincremental scalar initializer--just return
5415          the element, after verifying there is just one.  */
5416       if (constructor_elements == 0)
5417         {
5418           error_init ("empty scalar initializer");
5419           constructor = error_mark_node;
5420         }
5421       else if (TREE_CHAIN (constructor_elements) != 0)
5422         {
5423           error_init ("extra elements in scalar initializer");
5424           constructor = TREE_VALUE (constructor_elements);
5425         }
5426       else
5427         constructor = TREE_VALUE (constructor_elements);
5428     }
5429   else if (! constructor_incremental)
5430     {
5431       if (constructor_erroneous)
5432         constructor = error_mark_node;
5433       else
5434         {
5435           int momentary = suspend_momentary ();
5436
5437           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5438                                nreverse (constructor_elements));
5439           if (constructor_constant)
5440             TREE_CONSTANT (constructor) = 1;
5441           if (constructor_constant && constructor_simple)
5442             TREE_STATIC (constructor) = 1;
5443
5444           resume_momentary (momentary);
5445         }
5446     }
5447   else
5448     {
5449       tree filled;
5450       int momentary = suspend_momentary ();
5451
5452       if (TREE_CODE (constructor_type) == RECORD_TYPE
5453           || TREE_CODE (constructor_type) == UNION_TYPE)
5454         {
5455           /* Find the offset of the end of that field.  */
5456           filled = size_binop (CEIL_DIV_EXPR,
5457                                constructor_bit_index,
5458                                size_int (BITS_PER_UNIT));
5459         }
5460       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5461         {
5462           /* If initializing an array of unknown size,
5463              determine the size now.  */
5464           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5465               && TYPE_DOMAIN (constructor_type) == 0)
5466             {
5467               tree maxindex
5468                 = size_binop (MINUS_EXPR,
5469                               constructor_unfilled_index,
5470                               integer_one_node);
5471
5472               push_obstacks_nochange ();
5473               if (TREE_PERMANENT (constructor_type))
5474                 end_temporary_allocation ();
5475               maxindex = copy_node (maxindex);
5476               TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5477               TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5478
5479               /* TYPE_MAX_VALUE is always one less than the number of elements
5480                  in the array, because we start counting at zero.  Therefore,
5481                  warn only if the value is less than zero.  */
5482               if (pedantic
5483                   && (tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5484                       < 0))
5485                 error_with_decl (constructor_decl,
5486                                  "zero or negative array size `%s'");
5487               layout_type (constructor_type);
5488               size = int_size_in_bytes (constructor_type);
5489               pop_obstacks ();
5490             }
5491
5492           filled = size_binop (MULT_EXPR, constructor_unfilled_index,
5493                                size_in_bytes (TREE_TYPE (constructor_type)));
5494         }
5495       else
5496         filled = 0;
5497
5498       if (filled != 0)
5499         assemble_zeros (size - TREE_INT_CST_LOW (filled));
5500
5501       resume_momentary (momentary);
5502     }
5503
5504
5505   constructor_type = p->type;
5506   constructor_fields = p->fields;
5507   constructor_index = p->index;
5508   constructor_range_end = p->range_end;
5509   constructor_max_index = p->max_index;
5510   constructor_unfilled_index = p->unfilled_index;
5511   constructor_unfilled_fields = p->unfilled_fields;
5512   constructor_bit_index = p->bit_index;
5513   constructor_elements = p->elements;
5514   constructor_constant = p->constant;
5515   constructor_simple = p->simple;
5516   constructor_erroneous = p->erroneous;
5517   constructor_pending_elts = p->pending_elts;
5518   constructor_depth = p->depth;
5519   constructor_incremental = p->incremental;
5520   RESTORE_SPELLING_DEPTH (constructor_depth);
5521
5522   constructor_stack = p->next;
5523   free (p);
5524
5525   if (constructor == 0)
5526     {
5527       if (constructor_stack == 0)
5528         return error_mark_node;
5529       return NULL_TREE;
5530     }
5531   return constructor;
5532 }
5533
5534 /* Within an array initializer, specify the next index to be initialized.
5535    FIRST is that index.  If LAST is nonzero, then initialize a range
5536    of indices, running from FIRST through LAST.  */
5537
5538 void
5539 set_init_index (first, last)
5540      tree first, last;
5541 {
5542   while ((TREE_CODE (first) == NOP_EXPR
5543           || TREE_CODE (first) == CONVERT_EXPR
5544           || TREE_CODE (first) == NON_LVALUE_EXPR)
5545          && (TYPE_MODE (TREE_TYPE (first))
5546              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5547     (first) = TREE_OPERAND (first, 0);
5548   if (last)
5549     while ((TREE_CODE (last) == NOP_EXPR
5550             || TREE_CODE (last) == CONVERT_EXPR
5551             || TREE_CODE (last) == NON_LVALUE_EXPR)
5552            && (TYPE_MODE (TREE_TYPE (last))
5553                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5554       (last) = TREE_OPERAND (last, 0);
5555
5556   if (TREE_CODE (first) != INTEGER_CST)
5557     error_init ("nonconstant array index in initializer");
5558   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5559     error_init ("nonconstant array index in initializer");
5560   else if (! constructor_unfilled_index)
5561     error_init ("array index in non-array initializer");
5562   else if (tree_int_cst_lt (first, constructor_unfilled_index))
5563     error_init ("duplicate array index in initializer");
5564   else
5565     {
5566       TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (first);
5567       TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (first);
5568
5569       if (last != 0 && tree_int_cst_lt (last, first))
5570         error_init ("empty index range in initializer");
5571       else
5572         {
5573           if (pedantic)
5574             pedwarn ("ANSI C forbids specifying element to initialize");
5575           constructor_range_end = last;
5576         }
5577     }
5578 }
5579
5580 /* Within a struct initializer, specify the next field to be initialized.  */
5581
5582 void
5583 set_init_label (fieldname)
5584      tree fieldname;
5585 {
5586   tree tail;
5587   int passed = 0;
5588
5589   /* Don't die if an entire brace-pair level is superfluous
5590      in the containing level.  */
5591   if (constructor_type == 0)
5592     return;
5593
5594   for (tail = TYPE_FIELDS (constructor_type); tail;
5595        tail = TREE_CHAIN (tail))
5596     {
5597       if (tail == constructor_unfilled_fields)
5598         passed = 1;
5599       if (DECL_NAME (tail) == fieldname)
5600         break;
5601     }
5602
5603   if (tail == 0)
5604     error ("unknown field `%s' specified in initializer",
5605            IDENTIFIER_POINTER (fieldname));
5606   else if (!passed)
5607     error ("field `%s' already initialized",
5608            IDENTIFIER_POINTER (fieldname));
5609   else
5610     {
5611       constructor_fields = tail;
5612       if (pedantic)
5613         pedwarn ("ANSI C forbids specifying structure member to initialize");
5614     }
5615 }
5616 \f
5617 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5618    indentifies the initializer, either array index or field in a structure.
5619    VALUE is the value of that index or field.  */
5620
5621 static void
5622 add_pending_init (purpose, value)
5623      tree purpose, value;
5624 {
5625   struct init_node *p, **q, *r;
5626
5627   q = &constructor_pending_elts;
5628   p = 0;
5629
5630   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5631     {
5632       while (*q != 0)
5633         {
5634           p = *q;
5635           if (tree_int_cst_lt (purpose, p->purpose))
5636             q = &p->left;
5637           else if (tree_int_cst_lt (p->purpose, purpose))
5638             q = &p->right;
5639           else
5640             abort ();
5641         }
5642     }
5643   else
5644     {
5645       while (*q != NULL)
5646         {
5647           p = *q;
5648           if (tree_int_cst_lt (DECL_FIELD_BITPOS (purpose),
5649                                DECL_FIELD_BITPOS (p->purpose)))
5650             q = &p->left;
5651           else if (tree_int_cst_lt (DECL_FIELD_BITPOS (p->purpose),
5652                                     DECL_FIELD_BITPOS (purpose)))
5653             q = &p->right;
5654           else
5655             abort ();
5656         }
5657     }
5658
5659   r = (struct init_node *) oballoc (sizeof (struct init_node));
5660   r->purpose = purpose;
5661   r->value = value;
5662
5663   *q = r;
5664   r->parent = p;
5665   r->left = 0;
5666   r->right = 0;
5667   r->balance = 0;
5668
5669   while (p)
5670     {
5671       struct init_node *s;
5672
5673       if (r == p->left)
5674         {
5675           if (p->balance == 0)
5676             p->balance = -1;
5677           else if (p->balance < 0)
5678             {
5679               if (r->balance < 0)
5680                 {
5681                   /* L rotation. */
5682                   p->left = r->right;
5683                   if (p->left)
5684                     p->left->parent = p;
5685                   r->right = p;
5686
5687                   p->balance = 0;
5688                   r->balance = 0;
5689
5690                   s = p->parent;
5691                   p->parent = r;
5692                   r->parent = s;
5693                   if (s)
5694                     {
5695                       if (s->left == p)
5696                         s->left = r;
5697                       else
5698                         s->right = r;
5699                     }
5700                   else
5701                     constructor_pending_elts = r;
5702                 }
5703               else
5704                 {
5705                   /* LR rotation. */
5706                   struct init_node *t = r->right;
5707
5708                   r->right = t->left;
5709                   if (r->right)
5710                     r->right->parent = r;
5711                   t->left = r;
5712
5713                   p->left = t->right;
5714                   if (p->left)
5715                     p->left->parent = p;
5716                   t->right = p;
5717
5718                   p->balance = t->balance < 0;
5719                   r->balance = -(t->balance > 0);
5720                   t->balance = 0;
5721
5722                   s = p->parent;
5723                   p->parent = t;
5724                   r->parent = t;
5725                   t->parent = s;
5726                   if (s)
5727                     {
5728                       if (s->left == p)
5729                         s->left = t;
5730                       else
5731                         s->right = t;
5732                     }
5733                   else
5734                     constructor_pending_elts = t;
5735                 }
5736               break;
5737             }
5738           else
5739             {
5740               /* p->balance == +1; growth of left side balances the node.  */
5741               p->balance = 0;
5742               break;
5743             }
5744         }
5745       else /* r == p->right */
5746         {
5747           if (p->balance == 0)
5748             /* Growth propagation from right side.  */
5749             p->balance++;
5750           else if (p->balance > 0)
5751             {
5752               if (r->balance > 0)
5753                 {
5754                   /* R rotation. */
5755                   p->right = r->left;
5756                   if (p->right)
5757                     p->right->parent = p;
5758                   r->left = p;
5759
5760                   p->balance = 0;
5761                   r->balance = 0;
5762
5763                   s = p->parent;
5764                   p->parent = r;
5765                   r->parent = s;
5766                   if (s)
5767                     {
5768                       if (s->left == p)
5769                         s->left = r;
5770                       else
5771                         s->right = r;
5772                     }
5773                   else
5774                     constructor_pending_elts = r;
5775                 }
5776               else /* r->balance == -1 */
5777                 {
5778                   /* RL rotation */
5779                   struct init_node *t = r->left;
5780
5781                   r->left = t->right;
5782                   if (r->left)
5783                     r->left->parent = r;
5784                   t->right = r;
5785
5786                   p->right = t->left;
5787                   if (p->right)
5788                     p->right->parent = p;
5789                   t->left = p;
5790
5791                   r->balance = (t->balance < 0);
5792                   p->balance = -(t->balance > 0);
5793                   t->balance = 0;
5794
5795                   s = p->parent;
5796                   p->parent = t;
5797                   r->parent = t;
5798                   t->parent = s;
5799                   if (s)
5800                     {
5801                       if (s->left == p)
5802                         s->left = t;
5803                       else
5804                         s->right = t;
5805                     }
5806                   else
5807                     constructor_pending_elts = t;
5808                 }
5809               break;
5810             }
5811           else
5812             {
5813               /* p->balance == -1; growth of right side balances the node. */
5814               p->balance = 0;
5815               break;
5816             }
5817         }
5818
5819       r = p;
5820       p = p->parent;
5821     }
5822 }
5823
5824 /* Return nonzero if FIELD is equal to the index of a pending initializer.  */
5825
5826 static int
5827 pending_init_member (field)
5828      tree field;
5829 {
5830   struct init_node *p;
5831
5832   p = constructor_pending_elts;
5833   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5834     {
5835       while (p)
5836         {
5837           if (tree_int_cst_equal (field, p->purpose))
5838             return 1;
5839           else if (tree_int_cst_lt (field, p->purpose))
5840             p = p->left;
5841           else
5842             p = p->right;
5843         }
5844     }
5845   else
5846     {
5847       while (p)
5848         {
5849           if (field == p->purpose)
5850             return 1;
5851           else if (tree_int_cst_lt (DECL_FIELD_BITPOS (field),
5852                                     DECL_FIELD_BITPOS (p->purpose)))
5853             p = p->left;
5854           else
5855             p = p->right;
5856         }
5857     }
5858
5859   return 0;
5860 }
5861
5862 /* "Output" the next constructor element.
5863    At top level, really output it to assembler code now.
5864    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5865    TYPE is the data type that the containing data type wants here.
5866    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5867
5868    PENDING if non-nil means output pending elements that belong
5869    right after this element.  (PENDING is normally 1;
5870    it is 0 while outputting pending elements, to avoid recursion.)  */
5871
5872 static void
5873 output_init_element (value, type, field, pending)
5874      tree value, type, field;
5875      int pending;
5876 {
5877   int duplicate = 0;
5878
5879   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5880       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5881           && !(TREE_CODE (value) == STRING_CST
5882                && TREE_CODE (type) == ARRAY_TYPE
5883                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5884           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5885                          TYPE_MAIN_VARIANT (type))))
5886     value = default_conversion (value);
5887
5888   if (value == error_mark_node)
5889     constructor_erroneous = 1;
5890   else if (!TREE_CONSTANT (value))
5891     constructor_constant = 0;
5892   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5893            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5894                 || TREE_CODE (constructor_type) == UNION_TYPE)
5895                && DECL_C_BIT_FIELD (field)
5896                && TREE_CODE (value) != INTEGER_CST))
5897     constructor_simple = 0;
5898
5899   if (require_constant_value && ! TREE_CONSTANT (value))
5900     {
5901       error_init ("initializer element is not constant");
5902       value = error_mark_node;
5903     }
5904   else if (require_constant_elements
5905            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5906     {
5907       error_init ("initializer element is not computable at load time");
5908       value = error_mark_node;
5909     }
5910
5911   /* If this element duplicates one on constructor_pending_elts,
5912      print a message and ignore it.  Don't do this when we're
5913      processing elements taken off constructor_pending_elts,
5914      because we'd always get spurious errors.  */
5915   if (pending)
5916     {
5917       if (TREE_CODE (constructor_type) == RECORD_TYPE
5918           || TREE_CODE (constructor_type) == UNION_TYPE
5919           || TREE_CODE (constructor_type) == ARRAY_TYPE)
5920         {
5921           if (pending_init_member (field))
5922             {
5923               error_init ("duplicate initializer");
5924               duplicate = 1;
5925             }
5926         }
5927     }
5928
5929   /* If this element doesn't come next in sequence,
5930      put it on constructor_pending_elts.  */
5931   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5932       && !tree_int_cst_equal (field, constructor_unfilled_index))
5933     {
5934       if (! duplicate)
5935         /* The copy_node is needed in case field is actually
5936            constructor_index, which is modified in place.  */
5937         add_pending_init (copy_node (field),
5938                           digest_init (type, value, require_constant_value,
5939                                        require_constant_elements));
5940     }
5941   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5942            && field != constructor_unfilled_fields)
5943     {
5944       /* We do this for records but not for unions.  In a union,
5945          no matter which field is specified, it can be initialized
5946          right away since it starts at the beginning of the union.  */
5947       if (!duplicate)
5948         add_pending_init (field,
5949                           digest_init (type, value, require_constant_value,
5950                                        require_constant_elements));
5951     }
5952   else
5953     {
5954       /* Otherwise, output this element either to
5955          constructor_elements or to the assembler file.  */
5956
5957       if (!duplicate)
5958         {
5959           if (! constructor_incremental)
5960             {
5961               if (field && TREE_CODE (field) == INTEGER_CST)
5962                 field = copy_node (field);
5963               constructor_elements
5964                 = tree_cons (field, digest_init (type, value,
5965                                                  require_constant_value,
5966                                                  require_constant_elements),
5967                              constructor_elements);
5968             }
5969           else
5970             {
5971               /* Structure elements may require alignment.
5972                  Do this, if necessary.  */
5973               if (TREE_CODE (constructor_type) == RECORD_TYPE)
5974                 {
5975                   /* Advance to offset of this element.  */
5976                   if (! tree_int_cst_equal (constructor_bit_index,
5977                                             DECL_FIELD_BITPOS (field)))
5978                     {
5979                       /* By using unsigned arithmetic, the result will be
5980                          correct even in case of overflows, if BITS_PER_UNIT
5981                          is a power of two.  */
5982                       unsigned next = (TREE_INT_CST_LOW
5983                                        (DECL_FIELD_BITPOS (field))
5984                                        / (unsigned)BITS_PER_UNIT);
5985                       unsigned here = (TREE_INT_CST_LOW
5986                                        (constructor_bit_index)
5987                                        / (unsigned)BITS_PER_UNIT);
5988
5989                       assemble_zeros ((next - here)
5990                                       * (unsigned)BITS_PER_UNIT
5991                                       / (unsigned)BITS_PER_UNIT);
5992                     }
5993                 }
5994               output_constant (digest_init (type, value,
5995                                             require_constant_value,
5996                                             require_constant_elements),
5997                                int_size_in_bytes (type));
5998
5999               /* For a record or union,
6000                  keep track of end position of last field.  */
6001               if (TREE_CODE (constructor_type) == RECORD_TYPE
6002                   || TREE_CODE (constructor_type) == UNION_TYPE)
6003                 {
6004                   tree temp = size_binop (PLUS_EXPR, DECL_FIELD_BITPOS (field),
6005                                           DECL_SIZE (field));
6006                   TREE_INT_CST_LOW (constructor_bit_index)
6007                     = TREE_INT_CST_LOW (temp);
6008                   TREE_INT_CST_HIGH (constructor_bit_index)
6009                     = TREE_INT_CST_HIGH (temp);
6010                 }
6011             }
6012         }
6013
6014       /* Advance the variable that indicates sequential elements output.  */
6015       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6016         {
6017           tree tem = size_binop (PLUS_EXPR, constructor_unfilled_index,
6018                                  integer_one_node);
6019           TREE_INT_CST_LOW (constructor_unfilled_index)
6020             = TREE_INT_CST_LOW (tem);
6021           TREE_INT_CST_HIGH (constructor_unfilled_index)
6022             = TREE_INT_CST_HIGH (tem);
6023         }
6024       else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6025         {
6026           constructor_unfilled_fields =
6027             TREE_CHAIN (constructor_unfilled_fields);
6028           /* Skip any nameless bit fields.  */
6029           while (constructor_unfilled_fields != 0
6030                  && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6031                  && DECL_NAME (constructor_unfilled_fields) == 0)
6032             constructor_unfilled_fields =
6033               TREE_CHAIN (constructor_unfilled_fields);
6034         }
6035       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6036         constructor_unfilled_fields = 0;
6037
6038       /* Now output any pending elements which have become next.  */
6039       if (pending)
6040         output_pending_init_elements (0);
6041     }
6042 }
6043
6044 /* Output any pending elements which have become next.
6045    As we output elements, constructor_unfilled_{fields,index}
6046    advances, which may cause other elements to become next;
6047    if so, they too are output.
6048
6049    If ALL is 0, we return when there are
6050    no more pending elements to output now.
6051
6052    If ALL is 1, we output space as necessary so that
6053    we can output all the pending elements.  */
6054
6055 static void
6056 output_pending_init_elements (all)
6057      int all;
6058 {
6059   struct init_node *elt = constructor_pending_elts;
6060   tree next;
6061
6062  retry:
6063
6064   /* Look thru the whole pending tree.
6065      If we find an element that should be output now,
6066      output it.  Otherwise, set NEXT to the element
6067      that comes first among those still pending.  */
6068
6069   next = 0;
6070   while (elt)
6071     {
6072       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6073         {
6074           if (tree_int_cst_equal (elt->purpose,
6075                                   constructor_unfilled_index))
6076             output_init_element (elt->value,
6077                                  TREE_TYPE (constructor_type),
6078                                  constructor_unfilled_index, 0);
6079           else if (tree_int_cst_lt (constructor_unfilled_index,
6080                                     elt->purpose))
6081             {
6082               /* Advance to the next smaller node.  */
6083               if (elt->left)
6084                 elt = elt->left;
6085               else
6086                 {
6087                   /* We have reached the smallest node bigger than the
6088                      current unfilled index.  Fill the space first.  */
6089                   next = elt->purpose;
6090                   break;
6091                 }
6092             }
6093           else
6094             {
6095               /* Advance to the next bigger node.  */
6096               if (elt->right)
6097                 elt = elt->right;
6098               else
6099                 {
6100                   /* We have reached the biggest node in a subtree.  Find
6101                      the parent of it, which is the next bigger node.  */
6102                   while (elt->parent && elt->parent->right == elt)
6103                     elt = elt->parent;
6104                   elt = elt->parent;
6105                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6106                                               elt->purpose))
6107                     {
6108                       next = elt->purpose;
6109                       break;
6110                     }
6111                 }
6112             }
6113         }
6114       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6115                || TREE_CODE (constructor_type) == UNION_TYPE)
6116         {
6117           /* If the current record is complete we are done.  */
6118           if (constructor_unfilled_fields == 0)
6119             break;
6120           if (elt->purpose == constructor_unfilled_fields)
6121             {
6122               output_init_element (elt->value,
6123                                    TREE_TYPE (constructor_unfilled_fields),
6124                                    constructor_unfilled_fields,
6125                                    0);
6126             }
6127           else if (tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6128                                     DECL_FIELD_BITPOS (elt->purpose)))
6129             {
6130               /* Advance to the next smaller node.  */
6131               if (elt->left)
6132                 elt = elt->left;
6133               else
6134                 {
6135                   /* We have reached the smallest node bigger than the
6136                      current unfilled field.  Fill the space first.  */
6137                   next = elt->purpose;
6138                   break;
6139                 }
6140             }
6141           else
6142             {
6143               /* Advance to the next bigger node.  */
6144               if (elt->right)
6145                 elt = elt->right;
6146               else
6147                 {
6148                   /* We have reached the biggest node in a subtree.  Find
6149                      the parent of it, which is the next bigger node.  */
6150                   while (elt->parent && elt->parent->right == elt)
6151                     elt = elt->parent;
6152                   elt = elt->parent;
6153                   if (elt
6154                       && tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6155                                           DECL_FIELD_BITPOS (elt->purpose)))
6156                     {
6157                       next = elt->purpose;
6158                       break;
6159                     }
6160                 }
6161             }
6162         }
6163     }
6164
6165   /* Ordinarily return, but not if we want to output all
6166      and there are elements left.  */
6167   if (! (all && next != 0))
6168     return;
6169
6170   /* Generate space up to the position of NEXT.  */
6171   if (constructor_incremental)
6172     {
6173       tree filled;
6174       tree nextpos_tree = size_int (0);
6175
6176       if (TREE_CODE (constructor_type) == RECORD_TYPE
6177           || TREE_CODE (constructor_type) == UNION_TYPE)
6178         {
6179           tree tail;
6180           /* Find the last field written out, if any.  */
6181           for (tail = TYPE_FIELDS (constructor_type); tail;
6182                tail = TREE_CHAIN (tail))
6183             if (TREE_CHAIN (tail) == constructor_unfilled_fields)
6184               break;
6185
6186           if (tail)
6187             /* Find the offset of the end of that field.  */
6188             filled = size_binop (CEIL_DIV_EXPR,
6189                                  size_binop (PLUS_EXPR,
6190                                              DECL_FIELD_BITPOS (tail),
6191                                              DECL_SIZE (tail)),
6192                                  size_int (BITS_PER_UNIT));
6193           else
6194             filled = size_int (0);
6195
6196           nextpos_tree = size_binop (CEIL_DIV_EXPR,
6197                                      DECL_FIELD_BITPOS (next),
6198                                      size_int (BITS_PER_UNIT));
6199
6200           TREE_INT_CST_HIGH (constructor_bit_index)
6201             = TREE_INT_CST_HIGH (DECL_FIELD_BITPOS (next));
6202           TREE_INT_CST_LOW (constructor_bit_index)
6203             = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (next));
6204           constructor_unfilled_fields = next;
6205         }
6206       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6207         {
6208           filled = size_binop (MULT_EXPR, constructor_unfilled_index,
6209                                size_in_bytes (TREE_TYPE (constructor_type)));
6210           nextpos_tree
6211             = size_binop (MULT_EXPR, next,
6212                           size_in_bytes (TREE_TYPE (constructor_type)));
6213           TREE_INT_CST_LOW (constructor_unfilled_index)
6214             = TREE_INT_CST_LOW (next);
6215           TREE_INT_CST_HIGH (constructor_unfilled_index)
6216             = TREE_INT_CST_HIGH (next);
6217         }
6218       else
6219         filled = 0;
6220
6221       if (filled)
6222         {
6223           int nextpos = TREE_INT_CST_LOW (nextpos_tree);
6224
6225           assemble_zeros (nextpos - TREE_INT_CST_LOW (filled));
6226         }
6227     }
6228   else
6229     {
6230       /* If it's not incremental, just skip over the gap,
6231          so that after jumping to retry we will output the next
6232          successive element.  */
6233       if (TREE_CODE (constructor_type) == RECORD_TYPE
6234           || TREE_CODE (constructor_type) == UNION_TYPE)
6235         constructor_unfilled_fields = next;
6236       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6237         {
6238           TREE_INT_CST_LOW (constructor_unfilled_index)
6239             = TREE_INT_CST_LOW (next);
6240           TREE_INT_CST_HIGH (constructor_unfilled_index)
6241             = TREE_INT_CST_HIGH (next);
6242         }
6243     }
6244
6245   /* ELT now points to the node in the pending tree with the next
6246      initializer to output.  */
6247   goto retry;
6248 }
6249 \f
6250 /* Add one non-braced element to the current constructor level.
6251    This adjusts the current position within the constructor's type.
6252    This may also start or terminate implicit levels
6253    to handle a partly-braced initializer.
6254
6255    Once this has found the correct level for the new element,
6256    it calls output_init_element.
6257
6258    Note: if we are incrementally outputting this constructor,
6259    this function may be called with a null argument
6260    representing a sub-constructor that was already incrementally output.
6261    When that happens, we output nothing, but we do the bookkeeping
6262    to skip past that element of the current constructor.  */
6263
6264 void
6265 process_init_element (value)
6266      tree value;
6267 {
6268   tree orig_value = value;
6269   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6270
6271   /* Handle superfluous braces around string cst as in
6272      char x[] = {"foo"}; */
6273   if (string_flag
6274       && constructor_type
6275       && TREE_CODE (constructor_type) == ARRAY_TYPE
6276       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6277       && integer_zerop (constructor_unfilled_index))
6278     {
6279       if (constructor_stack->replacement_value)
6280         error_init ("excess elements in char array initializer");
6281       constructor_stack->replacement_value = value;
6282       return;
6283     }
6284
6285   if (constructor_stack->replacement_value != 0)
6286     {
6287       error_init ("excess elements in struct initializer");
6288       return;
6289     }
6290
6291   /* Ignore elements of a brace group if it is entirely superfluous
6292      and has already been diagnosed.  */
6293   if (constructor_type == 0)
6294     return;
6295
6296   /* If we've exhausted any levels that didn't have braces,
6297      pop them now.  */
6298   while (constructor_stack->implicit)
6299     {
6300       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6301            || TREE_CODE (constructor_type) == UNION_TYPE)
6302           && constructor_fields == 0)
6303         process_init_element (pop_init_level (1));
6304       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6305                && (constructor_max_index == 0
6306                    || tree_int_cst_lt (constructor_max_index,
6307                                        constructor_index)))
6308         process_init_element (pop_init_level (1));
6309       else
6310         break;
6311     }
6312
6313   while (1)
6314     {
6315       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6316         {
6317           tree fieldtype;
6318           enum tree_code fieldcode;
6319
6320           if (constructor_fields == 0)
6321             {
6322               pedwarn_init ("excess elements in struct initializer");
6323               break;
6324             }
6325
6326           fieldtype = TREE_TYPE (constructor_fields);
6327           if (fieldtype != error_mark_node)
6328             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6329           fieldcode = TREE_CODE (fieldtype);
6330
6331           /* Accept a string constant to initialize a subarray.  */
6332           if (value != 0
6333               && fieldcode == ARRAY_TYPE
6334               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6335               && string_flag)
6336             value = orig_value;
6337           /* Otherwise, if we have come to a subaggregate,
6338              and we don't have an element of its type, push into it.  */
6339           else if (value != 0 && !constructor_no_implicit
6340                    && value != error_mark_node
6341                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6342                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6343                        || fieldcode == UNION_TYPE))
6344             {
6345               push_init_level (1);
6346               continue;
6347             }
6348
6349           if (value)
6350             {
6351               push_member_name (constructor_fields);
6352               output_init_element (value, fieldtype, constructor_fields, 1);
6353               RESTORE_SPELLING_DEPTH (constructor_depth);
6354             }
6355           else
6356             /* Do the bookkeeping for an element that was
6357                directly output as a constructor.  */
6358             {
6359               /* For a record, keep track of end position of last field.  */
6360               tree temp = size_binop (PLUS_EXPR,
6361                                       DECL_FIELD_BITPOS (constructor_fields),
6362                                       DECL_SIZE (constructor_fields));
6363               TREE_INT_CST_LOW (constructor_bit_index)
6364                 = TREE_INT_CST_LOW (temp);
6365               TREE_INT_CST_HIGH (constructor_bit_index)
6366                 = TREE_INT_CST_HIGH (temp);
6367
6368               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6369               /* Skip any nameless bit fields.  */
6370               while (constructor_unfilled_fields != 0
6371                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6372                      && DECL_NAME (constructor_unfilled_fields) == 0)
6373                 constructor_unfilled_fields =
6374                   TREE_CHAIN (constructor_unfilled_fields);
6375             }
6376
6377           constructor_fields = TREE_CHAIN (constructor_fields);
6378           /* Skip any nameless bit fields at the beginning.  */
6379           while (constructor_fields != 0
6380                  && DECL_C_BIT_FIELD (constructor_fields)
6381                  && DECL_NAME (constructor_fields) == 0)
6382             constructor_fields = TREE_CHAIN (constructor_fields);
6383           break;
6384         }
6385       if (TREE_CODE (constructor_type) == UNION_TYPE)
6386         {
6387           tree fieldtype;
6388           enum tree_code fieldcode;
6389
6390           if (constructor_fields == 0)
6391             {
6392               pedwarn_init ("excess elements in union initializer");
6393               break;
6394             }
6395
6396           fieldtype = TREE_TYPE (constructor_fields);
6397           if (fieldtype != error_mark_node)
6398             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6399           fieldcode = TREE_CODE (fieldtype);
6400
6401           /* Accept a string constant to initialize a subarray.  */
6402           if (value != 0
6403               && fieldcode == ARRAY_TYPE
6404               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6405               && string_flag)
6406             value = orig_value;
6407           /* Otherwise, if we have come to a subaggregate,
6408              and we don't have an element of its type, push into it.  */
6409           else if (value != 0 && !constructor_no_implicit
6410                    && value != error_mark_node
6411                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6412                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6413                        || fieldcode == UNION_TYPE))
6414             {
6415               push_init_level (1);
6416               continue;
6417             }
6418
6419           if (value)
6420             {
6421               push_member_name (constructor_fields);
6422               output_init_element (value, fieldtype, constructor_fields, 1);
6423               RESTORE_SPELLING_DEPTH (constructor_depth);
6424             }
6425           else
6426             /* Do the bookkeeping for an element that was
6427                directly output as a constructor.  */
6428             {
6429               TREE_INT_CST_LOW (constructor_bit_index)
6430                 = TREE_INT_CST_LOW (DECL_SIZE (constructor_fields));
6431               TREE_INT_CST_HIGH (constructor_bit_index)
6432                 = TREE_INT_CST_HIGH (DECL_SIZE (constructor_fields));
6433
6434               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6435             }
6436
6437           constructor_fields = 0;
6438           break;
6439         }
6440       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6441         {
6442           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6443           enum tree_code eltcode = TREE_CODE (elttype);
6444
6445           /* Accept a string constant to initialize a subarray.  */
6446           if (value != 0
6447               && eltcode == ARRAY_TYPE
6448               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6449               && string_flag)
6450             value = orig_value;
6451           /* Otherwise, if we have come to a subaggregate,
6452              and we don't have an element of its type, push into it.  */
6453           else if (value != 0 && !constructor_no_implicit
6454                    && value != error_mark_node
6455                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6456                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6457                        || eltcode == UNION_TYPE))
6458             {
6459               push_init_level (1);
6460               continue;
6461             }
6462
6463           if (constructor_max_index != 0
6464               && tree_int_cst_lt (constructor_max_index, constructor_index))
6465             {
6466               pedwarn_init ("excess elements in array initializer");
6467               break;
6468             }
6469
6470           /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once.  */
6471           if (constructor_range_end)
6472             {
6473               if (constructor_max_index != 0
6474                   && tree_int_cst_lt (constructor_max_index,
6475                                       constructor_range_end))
6476                 {
6477                   pedwarn_init ("excess elements in array initializer");
6478                   TREE_INT_CST_HIGH (constructor_range_end)
6479                     = TREE_INT_CST_HIGH (constructor_max_index);
6480                   TREE_INT_CST_LOW (constructor_range_end)
6481                     = TREE_INT_CST_LOW (constructor_max_index);
6482                 }
6483
6484               value = save_expr (value);
6485             }
6486
6487           /* Now output the actual element.
6488              Ordinarily, output once.
6489              If there is a range, repeat it till we advance past the range.  */
6490           do
6491             {
6492               tree tem;
6493
6494               if (value)
6495                 {
6496                   push_array_bounds (TREE_INT_CST_LOW (constructor_index));
6497                   output_init_element (value, elttype, constructor_index, 1);
6498                   RESTORE_SPELLING_DEPTH (constructor_depth);
6499                 }
6500
6501               tem = size_binop (PLUS_EXPR, constructor_index,
6502                                 integer_one_node);
6503               TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (tem);
6504               TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (tem);
6505
6506               if (!value)
6507                 /* If we are doing the bookkeeping for an element that was
6508                    directly output as a constructor,
6509                    we must update constructor_unfilled_index.  */
6510                 {
6511                   TREE_INT_CST_LOW (constructor_unfilled_index)
6512                     = TREE_INT_CST_LOW (constructor_index);
6513                   TREE_INT_CST_HIGH (constructor_unfilled_index)
6514                     = TREE_INT_CST_HIGH (constructor_index);
6515                 }
6516             }
6517           while (! (constructor_range_end == 0
6518                     || tree_int_cst_lt (constructor_range_end,
6519                                         constructor_index)));
6520
6521           break;
6522         }
6523
6524       /* Handle the sole element allowed in a braced initializer
6525          for a scalar variable.  */
6526       if (constructor_fields == 0)
6527         {
6528           pedwarn_init ("excess elements in scalar initializer");
6529           break;
6530         }
6531
6532       if (value)
6533         output_init_element (value, constructor_type, NULL_TREE, 1);
6534       constructor_fields = 0;
6535       break;
6536     }
6537
6538   /* If the (lexically) previous elments are not now saved,
6539      we can discard the storage for them.  */
6540   if (constructor_incremental && constructor_pending_elts == 0 && value != 0
6541       && constructor_stack == 0)
6542     clear_momentary ();
6543 }
6544 \f
6545 /* Expand an ASM statement with operands, handling output operands
6546    that are not variables or INDIRECT_REFS by transforming such
6547    cases into cases that expand_asm_operands can handle.
6548
6549    Arguments are same as for expand_asm_operands.  */
6550
6551 void
6552 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6553      tree string, outputs, inputs, clobbers;
6554      int vol;
6555      char *filename;
6556      int line;
6557 {
6558   int noutputs = list_length (outputs);
6559   register int i;
6560   /* o[I] is the place that output number I should be written.  */
6561   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6562   register tree tail;
6563
6564   if (TREE_CODE (string) == ADDR_EXPR)
6565     string = TREE_OPERAND (string, 0);
6566   if (TREE_CODE (string) != STRING_CST)
6567     {
6568       error ("asm template is not a string constant");
6569       return;
6570     }
6571
6572   /* Record the contents of OUTPUTS before it is modified.  */
6573   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6574     {
6575       tree output = TREE_VALUE (tail);
6576
6577       /* We can remove conversions that just change the type, not the mode.  */
6578       STRIP_NOPS (output);
6579       o[i] = output;
6580
6581       /* Allow conversions as LHS here.  build_modify_expr as called below
6582          will do the right thing with them.  */
6583       while (TREE_CODE (output) == NOP_EXPR
6584              || TREE_CODE (output) == CONVERT_EXPR
6585              || TREE_CODE (output) == FLOAT_EXPR
6586              || TREE_CODE (output) == FIX_TRUNC_EXPR
6587              || TREE_CODE (output) == FIX_FLOOR_EXPR
6588              || TREE_CODE (output) == FIX_ROUND_EXPR
6589              || TREE_CODE (output) == FIX_CEIL_EXPR)
6590         output = TREE_OPERAND (output, 0);
6591
6592       lvalue_or_else (o[i], "invalid lvalue in asm statement");
6593     }
6594
6595   /* Perform default conversions on array and function inputs.  */
6596   /* Don't do this for other types--
6597      it would screw up operands expected to be in memory.  */
6598   for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6599     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6600         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6601       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6602
6603   /* Generate the ASM_OPERANDS insn;
6604      store into the TREE_VALUEs of OUTPUTS some trees for
6605      where the values were actually stored.  */
6606   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6607
6608   /* Copy all the intermediate outputs into the specified outputs.  */
6609   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6610     {
6611       if (o[i] != TREE_VALUE (tail))
6612         {
6613           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6614                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6615           free_temp_slots ();
6616         }
6617       /* Detect modification of read-only values.
6618          (Otherwise done by build_modify_expr.)  */
6619       else
6620         {
6621           tree type = TREE_TYPE (o[i]);
6622           if (TREE_READONLY (o[i])
6623               || TYPE_READONLY (type)
6624               || ((TREE_CODE (type) == RECORD_TYPE
6625                    || TREE_CODE (type) == UNION_TYPE)
6626                   && C_TYPE_FIELDS_READONLY (type)))
6627             readonly_warning (o[i], "modification by `asm'");
6628         }
6629     }
6630
6631   /* Those MODIFY_EXPRs could do autoincrements.  */
6632   emit_queue ();
6633 }
6634 \f
6635 /* Expand a C `return' statement.
6636    RETVAL is the expression for what to return,
6637    or a null pointer for `return;' with no value.  */
6638
6639 void
6640 c_expand_return (retval)
6641      tree retval;
6642 {
6643   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6644
6645   if (TREE_THIS_VOLATILE (current_function_decl))
6646     warning ("function declared `noreturn' has a `return' statement");
6647
6648   if (!retval)
6649     {
6650       current_function_returns_null = 1;
6651       if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6652         warning ("`return' with no value, in function returning non-void");
6653       expand_null_return ();
6654     }
6655   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6656     {
6657       current_function_returns_null = 1;
6658       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6659         pedwarn ("`return' with a value, in function returning void");
6660       expand_return (retval);
6661     }
6662   else
6663     {
6664       tree t = convert_for_assignment (valtype, retval, _("return"),
6665                                        NULL_TREE, NULL_TREE, 0);
6666       tree res = DECL_RESULT (current_function_decl);
6667       tree inner;
6668
6669       if (t == error_mark_node)
6670         return;
6671
6672       inner = t = convert (TREE_TYPE (res), t);
6673
6674       /* Strip any conversions, additions, and subtractions, and see if
6675          we are returning the address of a local variable.  Warn if so.  */
6676       while (1)
6677         {
6678           switch (TREE_CODE (inner))
6679             {
6680             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6681             case PLUS_EXPR:
6682               inner = TREE_OPERAND (inner, 0);
6683               continue;
6684
6685             case MINUS_EXPR:
6686               /* If the second operand of the MINUS_EXPR has a pointer
6687                  type (or is converted from it), this may be valid, so
6688                  don't give a warning.  */
6689               {
6690                 tree op1 = TREE_OPERAND (inner, 1);
6691
6692                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6693                        && (TREE_CODE (op1) == NOP_EXPR
6694                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6695                            || TREE_CODE (op1) == CONVERT_EXPR))
6696                   op1 = TREE_OPERAND (op1, 0);
6697
6698                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6699                   break;
6700
6701                 inner = TREE_OPERAND (inner, 0);
6702                 continue;
6703               }
6704
6705             case ADDR_EXPR:
6706               inner = TREE_OPERAND (inner, 0);
6707
6708               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6709                 inner = TREE_OPERAND (inner, 0);
6710
6711               if (TREE_CODE (inner) == VAR_DECL
6712                   && ! DECL_EXTERNAL (inner)
6713                   && ! TREE_STATIC (inner)
6714                   && DECL_CONTEXT (inner) == current_function_decl)
6715                 warning ("function returns address of local variable");
6716               break;
6717
6718             default:
6719               break;
6720             }
6721
6722           break;
6723         }
6724
6725       t = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6726       TREE_SIDE_EFFECTS (t) = 1;
6727       expand_return (t);
6728       current_function_returns_value = 1;
6729     }
6730 }
6731 \f
6732 /* Start a C switch statement, testing expression EXP.
6733    Return EXP if it is valid, an error node otherwise.  */
6734
6735 tree
6736 c_expand_start_case (exp)
6737      tree exp;
6738 {
6739   register enum tree_code code;
6740   tree type;
6741
6742   if (TREE_CODE (exp) == ERROR_MARK)
6743     return exp;
6744
6745   code = TREE_CODE (TREE_TYPE (exp));
6746   type = TREE_TYPE (exp);
6747
6748   if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
6749     {
6750       error ("switch quantity not an integer");
6751       exp = error_mark_node;
6752     }
6753   else
6754     {
6755       tree index;
6756       type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6757
6758       if (warn_traditional
6759           && ! in_system_header
6760           && (type == long_integer_type_node
6761               || type == long_unsigned_type_node))
6762         pedwarn ("`long' switch expression not converted to `int' in ANSI C");
6763
6764       exp = default_conversion (exp);
6765       type = TREE_TYPE (exp);
6766       index = get_unwidened (exp, NULL_TREE);
6767       /* We can't strip a conversion from a signed type to an unsigned,
6768          because if we did, int_fits_type_p would do the wrong thing
6769          when checking case values for being in range,
6770          and it's too hard to do the right thing.  */
6771       if (TREE_UNSIGNED (TREE_TYPE (exp))
6772           == TREE_UNSIGNED (TREE_TYPE (index)))
6773         exp = index;
6774     }
6775
6776   expand_start_case (1, exp, type, "switch statement");
6777
6778   return exp;
6779 }