gcc/c-typeck.c

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