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