gcc/c-typeck.c

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