gcc/c-typeck.c

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