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