gcc/c-typeck.c

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