gcc/c-typeck.c

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