gcc/c-typeck.c

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