gcc/c-typeck.c

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