gcc/c-typeck.c

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