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 == TREE_TYPE (val))
1655                         /* No warning if function asks for enum
1656                            and the actual arg is that enum type.  */
1657                         ;
1658                       else if (formal_prec != TYPE_PRECISION (type1))
1659                         warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1660                       else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1661                         ;
1662                       /* Don't complain if the formal parameter type
1663                          is an enum, because we can't tell now whether
1664                          the value was an enum--even the same enum.  */
1665                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
1666                         ;
1667                       else if (TREE_CODE (val) == INTEGER_CST
1668                                && int_fits_type_p (val, type))
1669                         /* Change in signedness doesn't matter
1670                            if a constant value is unaffected.  */
1671                         ;
1672                       /* Likewise for a constant in a NOP_EXPR.  */
1673                       else if (TREE_CODE (val) == NOP_EXPR
1674                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1675                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
1676                         ;
1677 #if 0 /* We never get such tree structure here.  */
1678                       else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1679                                && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1680                                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1681                         /* Change in signedness doesn't matter
1682                            if an enum value is unaffected.  */
1683                         ;
1684 #endif
1685                       /* If the value is extended from a narrower
1686                          unsigned type, it doesn't matter whether we
1687                          pass it as signed or unsigned; the value
1688                          certainly is the same either way.  */
1689                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1690                                && TREE_UNSIGNED (TREE_TYPE (val)))
1691                         ;
1692                       else if (TREE_UNSIGNED (type))
1693                         warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1694                       else
1695                         warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1696                     }
1697                 }
1698
1699               parmval = convert_for_assignment (type, val,
1700                                                 (char *) 0, /* arg passing  */
1701                                                 fundecl, name, parmnum + 1);
1702
1703               if (PROMOTE_PROTOTYPES
1704                   && INTEGRAL_TYPE_P (type)
1705                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1706                 parmval = default_conversion (parmval);
1707             }
1708           result = tree_cons (NULL_TREE, parmval, result);
1709         }
1710       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1711                && (TYPE_PRECISION (TREE_TYPE (val))
1712                    < TYPE_PRECISION (double_type_node)))
1713         /* Convert `float' to `double'.  */
1714         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1715       else
1716         /* Convert `short' and `char' to full-size `int'.  */
1717         result = tree_cons (NULL_TREE, default_conversion (val), result);
1718
1719       if (typetail)
1720         typetail = TREE_CHAIN (typetail);
1721     }
1722
1723   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1724     {
1725       if (name)
1726         error ("too few arguments to function `%s'",
1727                IDENTIFIER_POINTER (name));
1728       else
1729         error ("too few arguments to function");
1730     }
1731
1732   return nreverse (result);
1733 }
1734 \f
1735 /* This is the entry point used by the parser
1736    for binary operators in the input.
1737    In addition to constructing the expression,
1738    we check for operands that were written with other binary operators
1739    in a way that is likely to confuse the user.  */
1740
1741 tree
1742 parser_build_binary_op (code, arg1, arg2)
1743      enum tree_code code;
1744      tree arg1, arg2;
1745 {
1746   tree result = build_binary_op (code, arg1, arg2, 1);
1747
1748   char class;
1749   char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1750   char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1751   enum tree_code code1 = ERROR_MARK;
1752   enum tree_code code2 = ERROR_MARK;
1753
1754   if (class1 == 'e' || class1 == '1'
1755       || class1 == '2' || class1 == '<')
1756     code1 = C_EXP_ORIGINAL_CODE (arg1);
1757   if (class2 == 'e' || class2 == '1'
1758       || class2 == '2' || class2 == '<')
1759     code2 = C_EXP_ORIGINAL_CODE (arg2);
1760
1761   /* Check for cases such as x+y<<z which users are likely
1762      to misinterpret.  If parens are used, C_EXP_ORIGINAL_CODE
1763      is cleared to prevent these warnings.  */
1764   if (warn_parentheses)
1765     {
1766       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1767         {
1768           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1769               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1770             warning ("suggest parentheses around + or - inside shift");
1771         }
1772
1773       if (code == TRUTH_ORIF_EXPR)
1774         {
1775           if (code1 == TRUTH_ANDIF_EXPR
1776               || code2 == TRUTH_ANDIF_EXPR)
1777             warning ("suggest parentheses around && within ||");
1778         }
1779
1780       if (code == BIT_IOR_EXPR)
1781         {
1782           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1783               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1784               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1785               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1786             warning ("suggest parentheses around arithmetic in operand of |");
1787           /* Check cases like x|y==z */
1788           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1789             warning ("suggest parentheses around comparison in operand of |");
1790         }
1791
1792       if (code == BIT_XOR_EXPR)
1793         {
1794           if (code1 == BIT_AND_EXPR
1795               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1796               || code2 == BIT_AND_EXPR
1797               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1798             warning ("suggest parentheses around arithmetic in operand of ^");
1799           /* Check cases like x^y==z */
1800           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1801             warning ("suggest parentheses around comparison in operand of ^");
1802         }
1803
1804       if (code == BIT_AND_EXPR)
1805         {
1806           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1807               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1808             warning ("suggest parentheses around + or - in operand of &");
1809           /* Check cases like x&y==z */
1810           if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1811             warning ("suggest parentheses around comparison in operand of &");
1812         }
1813     }
1814
1815   /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
1816   if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1817       && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1818     warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1819
1820   unsigned_conversion_warning (result, arg1);
1821   unsigned_conversion_warning (result, arg2);
1822   overflow_warning (result);
1823
1824   class = TREE_CODE_CLASS (TREE_CODE (result));
1825
1826   /* Record the code that was specified in the source,
1827      for the sake of warnings about confusing nesting.  */
1828   if (class == 'e' || class == '1'
1829       || class == '2' || class == '<')
1830     C_SET_EXP_ORIGINAL_CODE (result, code);
1831   else
1832     {
1833       int flag = TREE_CONSTANT (result);
1834       /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1835          so that convert_for_assignment wouldn't strip it.
1836          That way, we got warnings for things like p = (1 - 1).
1837          But it turns out we should not get those warnings.  */
1838       result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1839       C_SET_EXP_ORIGINAL_CODE (result, code);
1840       TREE_CONSTANT (result) = flag;
1841     }
1842
1843   return result;
1844 }
1845
1846 /* Build a binary-operation expression without default conversions.
1847    CODE is the kind of expression to build.
1848    This function differs from `build' in several ways:
1849    the data type of the result is computed and recorded in it,
1850    warnings are generated if arg data types are invalid,
1851    special handling for addition and subtraction of pointers is known,
1852    and some optimization is done (operations on narrow ints
1853    are done in the narrower type when that gives the same result).
1854    Constant folding is also done before the result is returned.
1855
1856    Note that the operands will never have enumeral types, or function
1857    or array types, because either they will have the default conversions
1858    performed or they have both just been converted to some other type in which
1859    the arithmetic is to be done.  */
1860
1861 tree
1862 build_binary_op (code, orig_op0, orig_op1, convert_p)
1863      enum tree_code code;
1864      tree orig_op0, orig_op1;
1865      int convert_p;
1866 {
1867   tree type0, type1;
1868   enum tree_code code0, code1;
1869   tree op0, op1;
1870
1871   /* Expression code to give to the expression when it is built.
1872      Normally this is CODE, which is what the caller asked for,
1873      but in some special cases we change it.  */
1874   enum tree_code resultcode = code;
1875
1876   /* Data type in which the computation is to be performed.
1877      In the simplest cases this is the common type of the arguments.  */
1878   tree result_type = NULL;
1879
1880   /* Nonzero means operands have already been type-converted
1881      in whatever way is necessary.
1882      Zero means they need to be converted to RESULT_TYPE.  */
1883   int converted = 0;
1884
1885   /* Nonzero means create the expression with this type, rather than
1886      RESULT_TYPE.  */
1887   tree build_type = 0;
1888
1889   /* Nonzero means after finally constructing the expression
1890      convert it to this type.  */
1891   tree final_type = 0;
1892
1893   /* Nonzero if this is an operation like MIN or MAX which can
1894      safely be computed in short if both args are promoted shorts.
1895      Also implies COMMON.
1896      -1 indicates a bitwise operation; this makes a difference
1897      in the exact conditions for when it is safe to do the operation
1898      in a narrower mode.  */
1899   int shorten = 0;
1900
1901   /* Nonzero if this is a comparison operation;
1902      if both args are promoted shorts, compare the original shorts.
1903      Also implies COMMON.  */
1904   int short_compare = 0;
1905
1906   /* Nonzero if this is a right-shift operation, which can be computed on the
1907      original short and then promoted if the operand is a promoted short.  */
1908   int short_shift = 0;
1909
1910   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
1911   int common = 0;
1912
1913   if (convert_p)
1914     {
1915       op0 = default_conversion (orig_op0);
1916       op1 = default_conversion (orig_op1);
1917     }
1918   else
1919     {
1920       op0 = orig_op0;
1921       op1 = orig_op1;
1922     }
1923
1924   type0 = TREE_TYPE (op0);
1925   type1 = TREE_TYPE (op1);
1926
1927   /* The expression codes of the data types of the arguments tell us
1928      whether the arguments are integers, floating, pointers, etc.  */
1929   code0 = TREE_CODE (type0);
1930   code1 = TREE_CODE (type1);
1931
1932   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1933   STRIP_TYPE_NOPS (op0);
1934   STRIP_TYPE_NOPS (op1);
1935
1936   /* If an error was already reported for one of the arguments,
1937      avoid reporting another error.  */
1938
1939   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
1940     return error_mark_node;
1941
1942   switch (code)
1943     {
1944     case PLUS_EXPR:
1945       /* Handle the pointer + int case.  */
1946       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1947         return pointer_int_sum (PLUS_EXPR, op0, op1);
1948       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
1949         return pointer_int_sum (PLUS_EXPR, op1, op0);
1950       else
1951         common = 1;
1952       break;
1953
1954     case MINUS_EXPR:
1955       /* Subtraction of two similar pointers.
1956          We must subtract them as integers, then divide by object size.  */
1957       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
1958           && comp_target_types (type0, type1))
1959         return pointer_diff (op0, op1);
1960       /* Handle pointer minus int.  Just like pointer plus int.  */
1961       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1962         return pointer_int_sum (MINUS_EXPR, op0, op1);
1963       else
1964         common = 1;
1965       break;
1966
1967     case MULT_EXPR:
1968       common = 1;
1969       break;
1970
1971     case TRUNC_DIV_EXPR:
1972     case CEIL_DIV_EXPR:
1973     case FLOOR_DIV_EXPR:
1974     case ROUND_DIV_EXPR:
1975     case EXACT_DIV_EXPR:
1976       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
1977            || code0 == COMPLEX_TYPE)
1978           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
1979               || code1 == COMPLEX_TYPE))
1980         {
1981           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
1982             resultcode = RDIV_EXPR;
1983           else
1984             /* Although it would be tempting to shorten always here, that
1985                loses on some targets, since the modulo instruction is
1986                undefined if the quotient can't be represented in the
1987                computation mode.  We shorten only if unsigned or if
1988                dividing by something we know != -1.  */
1989             shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
1990                        || (TREE_CODE (op1) == INTEGER_CST
1991                            && ! integer_all_onesp (op1)));
1992           common = 1;
1993         }
1994       break;
1995
1996     case BIT_AND_EXPR:
1997     case BIT_ANDTC_EXPR:
1998     case BIT_IOR_EXPR:
1999     case BIT_XOR_EXPR:
2000       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2001         shorten = -1;
2002       /* If one operand is a constant, and the other is a short type
2003          that has been converted to an int,
2004          really do the work in the short type and then convert the
2005          result to int.  If we are lucky, the constant will be 0 or 1
2006          in the short type, making the entire operation go away.  */
2007       if (TREE_CODE (op0) == INTEGER_CST
2008           && TREE_CODE (op1) == NOP_EXPR
2009           && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2010           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2011         {
2012           final_type = result_type;
2013           op1 = TREE_OPERAND (op1, 0);
2014           result_type = TREE_TYPE (op1);
2015         }
2016       if (TREE_CODE (op1) == INTEGER_CST
2017           && TREE_CODE (op0) == NOP_EXPR
2018           && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2019           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2020         {
2021           final_type = result_type;
2022           op0 = TREE_OPERAND (op0, 0);
2023           result_type = TREE_TYPE (op0);
2024         }
2025       break;
2026
2027     case TRUNC_MOD_EXPR:
2028     case FLOOR_MOD_EXPR:
2029       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2030         {
2031           /* Although it would be tempting to shorten always here, that loses
2032              on some targets, since the modulo instruction is undefined if the
2033              quotient can't be represented in the computation mode.  We shorten
2034              only if unsigned or if dividing by something we know != -1.  */
2035           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2036                      || (TREE_CODE (op1) == INTEGER_CST
2037                          && ! integer_all_onesp (op1)));
2038           common = 1;
2039         }
2040       break;
2041
2042     case TRUTH_ANDIF_EXPR:
2043     case TRUTH_ORIF_EXPR:
2044     case TRUTH_AND_EXPR:
2045     case TRUTH_OR_EXPR:
2046     case TRUTH_XOR_EXPR:
2047       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2048            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2049           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2050               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2051         {
2052           /* Result of these operations is always an int,
2053              but that does not mean the operands should be
2054              converted to ints!  */
2055           result_type = integer_type_node;
2056           op0 = truthvalue_conversion (op0);
2057           op1 = truthvalue_conversion (op1);
2058           converted = 1;
2059         }
2060       break;
2061
2062       /* Shift operations: result has same type as first operand;
2063          always convert second operand to int.
2064          Also set SHORT_SHIFT if shifting rightward.  */
2065
2066     case RSHIFT_EXPR:
2067       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2068         {
2069           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2070             {
2071               if (tree_int_cst_sgn (op1) < 0)
2072                 warning ("right shift count is negative");
2073               else
2074                 {
2075                   if (! integer_zerop (op1))
2076                     short_shift = 1;
2077
2078                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2079                     warning ("right shift count >= width of type");
2080                 }
2081             }
2082
2083           /* Use the type of the value to be shifted.
2084              This is what most traditional C compilers do.  */
2085           result_type = type0;
2086           /* Unless traditional, convert the shift-count to an integer,
2087              regardless of size of value being shifted.  */
2088           if (! flag_traditional)
2089             {
2090               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2091                 op1 = convert (integer_type_node, op1);
2092               /* Avoid converting op1 to result_type later.  */
2093               converted = 1;
2094             }
2095         }
2096       break;
2097
2098     case LSHIFT_EXPR:
2099       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2100         {
2101           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2102             {
2103               if (tree_int_cst_sgn (op1) < 0)
2104                 warning ("left shift count is negative");
2105
2106               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2107                 warning ("left shift count >= width of type");
2108             }
2109
2110           /* Use the type of the value to be shifted.
2111              This is what most traditional C compilers do.  */
2112           result_type = type0;
2113           /* Unless traditional, convert the shift-count to an integer,
2114              regardless of size of value being shifted.  */
2115           if (! flag_traditional)
2116             {
2117               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2118                 op1 = convert (integer_type_node, op1);
2119               /* Avoid converting op1 to result_type later.  */
2120               converted = 1;
2121             }
2122         }
2123       break;
2124
2125     case RROTATE_EXPR:
2126     case LROTATE_EXPR:
2127       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2128         {
2129           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2130             {
2131               if (tree_int_cst_sgn (op1) < 0)
2132                 warning ("shift count is negative");
2133               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
2134                 warning ("shift count >= width of type");
2135             }
2136
2137           /* Use the type of the value to be shifted.
2138              This is what most traditional C compilers do.  */
2139           result_type = type0;
2140           /* Unless traditional, convert the shift-count to an integer,
2141              regardless of size of value being shifted.  */
2142           if (! flag_traditional)
2143             {
2144               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2145                 op1 = convert (integer_type_node, op1);
2146               /* Avoid converting op1 to result_type later.  */
2147               converted = 1;
2148             }
2149         }
2150       break;
2151
2152     case EQ_EXPR:
2153     case NE_EXPR:
2154       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
2155         warning ("comparing floating point with == or != is unsafe");
2156       /* Result of comparison is always int,
2157          but don't convert the args to int!  */
2158       build_type = integer_type_node;
2159       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2160            || code0 == COMPLEX_TYPE)
2161           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2162               || code1 == COMPLEX_TYPE))
2163         short_compare = 1;
2164       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2165         {
2166           tree tt0 = TREE_TYPE (type0);
2167           tree tt1 = TREE_TYPE (type1);
2168           /* Anything compares with void *.  void * compares with anything.
2169              Otherwise, the targets must be compatible
2170              and both must be object or both incomplete.  */
2171           if (comp_target_types (type0, type1))
2172             result_type = common_type (type0, type1);
2173           else if (VOID_TYPE_P (tt0))
2174             {
2175               /* op0 != orig_op0 detects the case of something
2176                  whose value is 0 but which isn't a valid null ptr const.  */
2177               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2178                   && TREE_CODE (tt1) == FUNCTION_TYPE)
2179                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2180             }
2181           else if (VOID_TYPE_P (tt1))
2182             {
2183               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2184                   && TREE_CODE (tt0) == FUNCTION_TYPE)
2185                 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
2186             }
2187           else
2188             pedwarn ("comparison of distinct pointer types lacks a cast");
2189
2190           if (result_type == NULL_TREE)
2191             result_type = ptr_type_node;
2192         }
2193       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2194                && integer_zerop (op1))
2195         result_type = type0;
2196       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2197                && integer_zerop (op0))
2198         result_type = type1;
2199       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2200         {
2201           result_type = type0;
2202           if (! flag_traditional)
2203             pedwarn ("comparison between pointer and integer");
2204         }
2205       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2206         {
2207           result_type = type1;
2208           if (! flag_traditional)
2209             pedwarn ("comparison between pointer and integer");
2210         }
2211       break;
2212
2213     case MAX_EXPR:
2214     case MIN_EXPR:
2215       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2216           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2217         shorten = 1;
2218       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2219         {
2220           if (comp_target_types (type0, type1))
2221             {
2222               result_type = common_type (type0, type1);
2223               if (pedantic
2224                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2225                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2226             }
2227           else
2228             {
2229               result_type = ptr_type_node;
2230               pedwarn ("comparison of distinct pointer types lacks a cast");
2231             }
2232         }
2233       break;
2234
2235     case LE_EXPR:
2236     case GE_EXPR:
2237     case LT_EXPR:
2238     case GT_EXPR:
2239       build_type = integer_type_node;
2240       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2241           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2242         short_compare = 1;
2243       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2244         {
2245           if (comp_target_types (type0, type1))
2246             {
2247               result_type = common_type (type0, type1);
2248               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
2249                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
2250                 pedwarn ("comparison of complete and incomplete pointers");
2251               else if (pedantic
2252                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2253                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
2254             }
2255           else
2256             {
2257               result_type = ptr_type_node;
2258               pedwarn ("comparison of distinct pointer types lacks a cast");
2259             }
2260         }
2261       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2262                && integer_zerop (op1))
2263         {
2264           result_type = type0;
2265           if (pedantic || extra_warnings)
2266             pedwarn ("ordered comparison of pointer with integer zero");
2267         }
2268       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2269                && integer_zerop (op0))
2270         {
2271           result_type = type1;
2272           if (pedantic)
2273             pedwarn ("ordered comparison of pointer with integer zero");
2274         }
2275       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2276         {
2277           result_type = type0;
2278           if (! flag_traditional)
2279             pedwarn ("comparison between pointer and integer");
2280         }
2281       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2282         {
2283           result_type = type1;
2284           if (! flag_traditional)
2285             pedwarn ("comparison between pointer and integer");
2286         }
2287       break;
2288
2289     case UNORDERED_EXPR:
2290     case ORDERED_EXPR:
2291     case UNLT_EXPR:
2292     case UNLE_EXPR:
2293     case UNGT_EXPR:
2294     case UNGE_EXPR:
2295     case UNEQ_EXPR:
2296       build_type = integer_type_node;
2297       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
2298         {
2299           error ("unordered comparison on non-floating point argument");
2300           return error_mark_node;
2301         }
2302       common = 1;
2303       break;
2304
2305     default:
2306       break;
2307     }
2308
2309   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2310       &&
2311       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2312     {
2313       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2314
2315       if (shorten || common || short_compare)
2316         result_type = common_type (type0, type1);
2317
2318       /* For certain operations (which identify themselves by shorten != 0)
2319          if both args were extended from the same smaller type,
2320          do the arithmetic in that type and then extend.
2321
2322          shorten !=0 and !=1 indicates a bitwise operation.
2323          For them, this optimization is safe only if
2324          both args are zero-extended or both are sign-extended.
2325          Otherwise, we might change the result.
2326          Eg, (short)-1 | (unsigned short)-1 is (int)-1
2327          but calculated in (unsigned short) it would be (unsigned short)-1.  */
2328
2329       if (shorten && none_complex)
2330         {
2331           int unsigned0, unsigned1;
2332           tree arg0 = get_narrower (op0, &unsigned0);
2333           tree arg1 = get_narrower (op1, &unsigned1);
2334           /* UNS is 1 if the operation to be done is an unsigned one.  */
2335           int uns = TREE_UNSIGNED (result_type);
2336           tree type;
2337
2338           final_type = result_type;
2339
2340           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2341              but it *requires* conversion to FINAL_TYPE.  */
2342
2343           if ((TYPE_PRECISION (TREE_TYPE (op0))
2344                == TYPE_PRECISION (TREE_TYPE (arg0)))
2345               && TREE_TYPE (op0) != final_type)
2346             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2347           if ((TYPE_PRECISION (TREE_TYPE (op1))
2348                == TYPE_PRECISION (TREE_TYPE (arg1)))
2349               && TREE_TYPE (op1) != final_type)
2350             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2351
2352           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
2353
2354           /* For bitwise operations, signedness of nominal type
2355              does not matter.  Consider only how operands were extended.  */
2356           if (shorten == -1)
2357             uns = unsigned0;
2358
2359           /* Note that in all three cases below we refrain from optimizing
2360              an unsigned operation on sign-extended args.
2361              That would not be valid.  */
2362
2363           /* Both args variable: if both extended in same way
2364              from same width, do it in that width.
2365              Do it unsigned if args were zero-extended.  */
2366           if ((TYPE_PRECISION (TREE_TYPE (arg0))
2367                < TYPE_PRECISION (result_type))
2368               && (TYPE_PRECISION (TREE_TYPE (arg1))
2369                   == TYPE_PRECISION (TREE_TYPE (arg0)))
2370               && unsigned0 == unsigned1
2371               && (unsigned0 || !uns))
2372             result_type
2373               = signed_or_unsigned_type (unsigned0,
2374                                          common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2375           else if (TREE_CODE (arg0) == INTEGER_CST
2376                    && (unsigned1 || !uns)
2377                    && (TYPE_PRECISION (TREE_TYPE (arg1))
2378                        < TYPE_PRECISION (result_type))
2379                    && (type = signed_or_unsigned_type (unsigned1,
2380                                                        TREE_TYPE (arg1)),
2381                        int_fits_type_p (arg0, type)))
2382             result_type = type;
2383           else if (TREE_CODE (arg1) == INTEGER_CST
2384                    && (unsigned0 || !uns)
2385                    && (TYPE_PRECISION (TREE_TYPE (arg0))
2386                        < TYPE_PRECISION (result_type))
2387                    && (type = signed_or_unsigned_type (unsigned0,
2388                                                        TREE_TYPE (arg0)),
2389                        int_fits_type_p (arg1, type)))
2390             result_type = type;
2391         }
2392
2393       /* Shifts can be shortened if shifting right.  */
2394
2395       if (short_shift)
2396         {
2397           int unsigned_arg;
2398           tree arg0 = get_narrower (op0, &unsigned_arg);
2399
2400           final_type = result_type;
2401
2402           if (arg0 == op0 && final_type == TREE_TYPE (op0))
2403             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2404
2405           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2406               /* We can shorten only if the shift count is less than the
2407                  number of bits in the smaller type size.  */
2408               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
2409               /* We cannot drop an unsigned shift after sign-extension.  */
2410               && (!TREE_UNSIGNED (final_type) || unsigned_arg))
2411             {
2412               /* Do an unsigned shift if the operand was zero-extended.  */
2413               result_type
2414                 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0));
2415               /* Convert value-to-be-shifted to that type.  */
2416               if (TREE_TYPE (op0) != result_type)
2417                 op0 = convert (result_type, op0);
2418               converted = 1;
2419             }
2420         }
2421
2422       /* Comparison operations are shortened too but differently.
2423          They identify themselves by setting short_compare = 1.  */
2424
2425       if (short_compare)
2426         {
2427           /* Don't write &op0, etc., because that would prevent op0
2428              from being kept in a register.
2429              Instead, make copies of the our local variables and
2430              pass the copies by reference, then copy them back afterward.  */
2431           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2432           enum tree_code xresultcode = resultcode;
2433           tree val
2434             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2435
2436           if (val != 0)
2437             return val;
2438
2439           op0 = xop0, op1 = xop1;
2440           converted = 1;
2441           resultcode = xresultcode;
2442
2443           if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2444               && skip_evaluation == 0)
2445             {
2446               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2447               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2448               int unsignedp0, unsignedp1;
2449               tree primop0 = get_narrower (op0, &unsignedp0);
2450               tree primop1 = get_narrower (op1, &unsignedp1);
2451
2452               xop0 = orig_op0;
2453               xop1 = orig_op1;
2454               STRIP_TYPE_NOPS (xop0);
2455               STRIP_TYPE_NOPS (xop1);
2456
2457               /* Give warnings for comparisons between signed and unsigned
2458                  quantities that may fail.
2459
2460                  Do the checking based on the original operand trees, so that
2461                  casts will be considered, but default promotions won't be.
2462
2463                  Do not warn if the comparison is being done in a signed type,
2464                  since the signed type will only be chosen if it can represent
2465                  all the values of the unsigned type.  */
2466               if (! TREE_UNSIGNED (result_type))
2467                 /* OK */;
2468               /* Do not warn if both operands are the same signedness.  */
2469               else if (op0_signed == op1_signed)
2470                 /* OK */;
2471               else
2472                 {
2473                   tree sop, uop;
2474
2475                   if (op0_signed)
2476                     sop = xop0, uop = xop1;
2477                   else
2478                     sop = xop1, uop = xop0;
2479
2480                   /* Do not warn if the signed quantity is an
2481                      unsuffixed integer literal (or some static
2482                      constant expression involving such literals or a
2483                      conditional expression involving such literals)
2484                      and it is non-negative.  */
2485                   if (tree_expr_nonnegative_p (sop))
2486                     /* OK */;
2487                   /* Do not warn if the comparison is an equality operation,
2488                      the unsigned quantity is an integral constant, and it
2489                      would fit in the result if the result were signed.  */
2490                   else if (TREE_CODE (uop) == INTEGER_CST
2491                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
2492                            && int_fits_type_p (uop, signed_type (result_type)))
2493                     /* OK */;
2494                   /* Do not warn if the unsigned quantity is an enumeration
2495                      constant and its maximum value would fit in the result
2496                      if the result were signed.  */
2497                   else if (TREE_CODE (uop) == INTEGER_CST
2498                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
2499                            && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)),
2500                                                signed_type (result_type)))
2501                     /* OK */;
2502                   else
2503                     warning ("comparison between signed and unsigned");
2504                 }
2505
2506               /* Warn if two unsigned values are being compared in a size
2507                  larger than their original size, and one (and only one) is the
2508                  result of a `~' operator.  This comparison will always fail.
2509
2510                  Also warn if one operand is a constant, and the constant
2511                  does not have all bits set that are set in the ~ operand
2512                  when it is extended.  */
2513
2514               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2515                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2516                 {
2517                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2518                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2519                                             &unsignedp0);
2520                   else
2521                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2522                                             &unsignedp1);
2523
2524                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
2525                     {
2526                       tree primop;
2527                       HOST_WIDE_INT constant, mask;
2528                       int unsignedp, bits;
2529
2530                       if (host_integerp (primop0, 0))
2531                         {
2532                           primop = primop1;
2533                           unsignedp = unsignedp1;
2534                           constant = tree_low_cst (primop0, 0);
2535                         }
2536                       else
2537                         {
2538                           primop = primop0;
2539                           unsignedp = unsignedp0;
2540                           constant = tree_low_cst (primop1, 0);
2541                         }
2542
2543                       bits = TYPE_PRECISION (TREE_TYPE (primop));
2544                       if (bits < TYPE_PRECISION (result_type)
2545                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
2546                         {
2547                           mask = (~ (HOST_WIDE_INT) 0) << bits;
2548                           if ((mask & constant) != mask)
2549                             warning ("comparison of promoted ~unsigned with constant");
2550                         }
2551                     }
2552                   else if (unsignedp0 && unsignedp1
2553                            && (TYPE_PRECISION (TREE_TYPE (primop0))
2554                                < TYPE_PRECISION (result_type))
2555                            && (TYPE_PRECISION (TREE_TYPE (primop1))
2556                                < TYPE_PRECISION (result_type)))
2557                     warning ("comparison of promoted ~unsigned with unsigned");
2558                 }
2559             }
2560         }
2561     }
2562
2563   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2564      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2565      Then the expression will be built.
2566      It will be given type FINAL_TYPE if that is nonzero;
2567      otherwise, it will be given type RESULT_TYPE.  */
2568
2569   if (!result_type)
2570     {
2571       binary_op_error (code);
2572       return error_mark_node;
2573     }
2574
2575   if (! converted)
2576     {
2577       if (TREE_TYPE (op0) != result_type)
2578         op0 = convert (result_type, op0);
2579       if (TREE_TYPE (op1) != result_type)
2580         op1 = convert (result_type, op1);
2581     }
2582
2583   if (build_type == NULL_TREE)
2584     build_type = result_type;
2585
2586   {
2587     tree result = build (resultcode, build_type, op0, op1);
2588     tree folded;
2589
2590     folded = fold (result);
2591     if (folded == result)
2592       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2593     if (final_type != 0)
2594       return convert (final_type, folded);
2595     return folded;
2596   }
2597 }
2598 \f
2599 /* Return a tree for the sum or difference (RESULTCODE says which)
2600    of pointer PTROP and integer INTOP.  */
2601
2602 static tree
2603 pointer_int_sum (resultcode, ptrop, intop)
2604      enum tree_code resultcode;
2605      tree ptrop, intop;
2606 {
2607   tree size_exp;
2608
2609   tree result;
2610   tree folded;
2611
2612   /* The result is a pointer of the same type that is being added.  */
2613
2614   tree result_type = TREE_TYPE (ptrop);
2615
2616   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2617     {
2618       if (pedantic || warn_pointer_arith)
2619         pedwarn ("pointer of type `void *' used in arithmetic");
2620       size_exp = integer_one_node;
2621     }
2622   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2623     {
2624       if (pedantic || warn_pointer_arith)
2625         pedwarn ("pointer to a function used in arithmetic");
2626       size_exp = integer_one_node;
2627     }
2628   else
2629     size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2630
2631   /* If what we are about to multiply by the size of the elements
2632      contains a constant term, apply distributive law
2633      and multiply that constant term separately.
2634      This helps produce common subexpressions.  */
2635
2636   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2637       && ! TREE_CONSTANT (intop)
2638       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2639       && TREE_CONSTANT (size_exp)
2640       /* If the constant comes from pointer subtraction,
2641          skip this optimization--it would cause an error.  */
2642       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2643       /* If the constant is unsigned, and smaller than the pointer size,
2644          then we must skip this optimization.  This is because it could cause
2645          an overflow error if the constant is negative but INTOP is not.  */
2646       && (! TREE_UNSIGNED (TREE_TYPE (intop))
2647           || (TYPE_PRECISION (TREE_TYPE (intop))
2648               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2649     {
2650       enum tree_code subcode = resultcode;
2651       tree int_type = TREE_TYPE (intop);
2652       if (TREE_CODE (intop) == MINUS_EXPR)
2653         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2654       /* Convert both subexpression types to the type of intop,
2655          because weird cases involving pointer arithmetic
2656          can result in a sum or difference with different type args.  */
2657       ptrop = build_binary_op (subcode, ptrop,
2658                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2659       intop = convert (int_type, TREE_OPERAND (intop, 0));
2660     }
2661
2662   /* Convert the integer argument to a type the same size as sizetype
2663      so the multiply won't overflow spuriously.  */
2664
2665   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2666       || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2667     intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2668                                     TREE_UNSIGNED (sizetype)), intop);
2669
2670   /* Replace the integer argument with a suitable product by the object size.
2671      Do this multiplication as signed, then convert to the appropriate
2672      pointer type (actually unsigned integral).  */
2673
2674   intop = convert (result_type,
2675                    build_binary_op (MULT_EXPR, intop,
2676                                     convert (TREE_TYPE (intop), size_exp), 1));
2677
2678   /* Create the sum or difference.  */
2679
2680   result = build (resultcode, result_type, ptrop, intop);
2681
2682   folded = fold (result);
2683   if (folded == result)
2684     TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2685   return folded;
2686 }
2687
2688 /* Return a tree for the difference of pointers OP0 and OP1.
2689    The resulting tree has type int.  */
2690
2691 static tree
2692 pointer_diff (op0, op1)
2693      tree op0, op1;
2694 {
2695   tree result, folded;
2696   tree restype = ptrdiff_type_node;
2697
2698   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2699   tree con0, con1, lit0, lit1;
2700   tree orig_op1 = op1;
2701
2702   if (pedantic || warn_pointer_arith)
2703     {
2704       if (TREE_CODE (target_type) == VOID_TYPE)
2705         pedwarn ("pointer of type `void *' used in subtraction");
2706       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2707         pedwarn ("pointer to a function used in subtraction");
2708     }
2709
2710   /* If the conversion to ptrdiff_type does anything like widening or
2711      converting a partial to an integral mode, we get a convert_expression
2712      that is in the way to do any simplifications.
2713      (fold-const.c doesn't know that the extra bits won't be needed.
2714      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2715      different mode in place.)
2716      So first try to find a common term here 'by hand'; we want to cover
2717      at least the cases that occur in legal static initializers.  */
2718   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2719   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2720
2721   if (TREE_CODE (con0) == PLUS_EXPR)
2722     {
2723       lit0 = TREE_OPERAND (con0, 1);
2724       con0 = TREE_OPERAND (con0, 0);
2725     }
2726   else
2727     lit0 = integer_zero_node;
2728
2729   if (TREE_CODE (con1) == PLUS_EXPR)
2730     {
2731       lit1 = TREE_OPERAND (con1, 1);
2732       con1 = TREE_OPERAND (con1, 0);
2733     }
2734   else
2735     lit1 = integer_zero_node;
2736
2737   if (operand_equal_p (con0, con1, 0))
2738     {
2739       op0 = lit0;
2740       op1 = lit1;
2741     }
2742
2743
2744   /* First do the subtraction as integers;
2745      then drop through to build the divide operator.
2746      Do not do default conversions on the minus operator
2747      in case restype is a short type.  */
2748
2749   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2750                          convert (restype, op1), 0);
2751   /* This generates an error if op1 is pointer to incomplete type.  */
2752   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2753     error ("arithmetic on pointer to an incomplete type");
2754
2755   /* This generates an error if op0 is pointer to incomplete type.  */
2756   op1 = c_size_in_bytes (target_type);
2757
2758   /* Divide by the size, in easiest possible way.  */
2759
2760   result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2761
2762   folded = fold (result);
2763   if (folded == result)
2764     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2765   return folded;
2766 }
2767 \f
2768 /* Construct and perhaps optimize a tree representation
2769    for a unary operation.  CODE, a tree_code, specifies the operation
2770    and XARG is the operand.  NOCONVERT nonzero suppresses
2771    the default promotions (such as from short to int).  */
2772
2773 tree
2774 build_unary_op (code, xarg, noconvert)
2775      enum tree_code code;
2776      tree xarg;
2777      int noconvert;
2778 {
2779   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2780   tree arg = xarg;
2781   tree argtype = 0;
2782   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2783   tree val;
2784
2785   if (typecode == ERROR_MARK)
2786     return error_mark_node;
2787   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2788     typecode = INTEGER_TYPE;
2789
2790   switch (code)
2791     {
2792     case CONVERT_EXPR:
2793       /* This is used for unary plus, because a CONVERT_EXPR
2794          is enough to prevent anybody from looking inside for
2795          associativity, but won't generate any code.  */
2796       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2797             || typecode == COMPLEX_TYPE))
2798         {
2799           error ("wrong type argument to unary plus");
2800           return error_mark_node;
2801         }
2802       else if (!noconvert)
2803         arg = default_conversion (arg);
2804       break;
2805
2806     case NEGATE_EXPR:
2807       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2808             || typecode == COMPLEX_TYPE))
2809         {
2810           error ("wrong type argument to unary minus");
2811           return error_mark_node;
2812         }
2813       else if (!noconvert)
2814         arg = default_conversion (arg);
2815       break;
2816
2817     case BIT_NOT_EXPR:
2818       if (typecode == COMPLEX_TYPE)
2819         {
2820           code = CONJ_EXPR;
2821           if (pedantic)
2822             pedwarn ("ISO C does not support `~' for complex conjugation");
2823           if (!noconvert)
2824             arg = default_conversion (arg);
2825         }
2826       else if (typecode != INTEGER_TYPE)
2827         {
2828           error ("wrong type argument to bit-complement");
2829           return error_mark_node;
2830         }
2831       else if (!noconvert)
2832         arg = default_conversion (arg);
2833       break;
2834
2835     case ABS_EXPR:
2836       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2837             || typecode == COMPLEX_TYPE))
2838         {
2839           error ("wrong type argument to abs");
2840           return error_mark_node;
2841         }
2842       else if (!noconvert)
2843         arg = default_conversion (arg);
2844       break;
2845
2846     case CONJ_EXPR:
2847       /* Conjugating a real value is a no-op, but allow it anyway.  */
2848       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2849             || typecode == COMPLEX_TYPE))
2850         {
2851           error ("wrong type argument to conjugation");
2852           return error_mark_node;
2853         }
2854       else if (!noconvert)
2855         arg = default_conversion (arg);
2856       break;
2857
2858     case TRUTH_NOT_EXPR:
2859       if (typecode != INTEGER_TYPE
2860           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2861           && typecode != COMPLEX_TYPE
2862           /* These will convert to a pointer.  */
2863           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2864         {
2865           error ("wrong type argument to unary exclamation mark");
2866           return error_mark_node;
2867         }
2868       arg = truthvalue_conversion (arg);
2869       return invert_truthvalue (arg);
2870
2871     case NOP_EXPR:
2872       break;
2873
2874     case REALPART_EXPR:
2875       if (TREE_CODE (arg) == COMPLEX_CST)
2876         return TREE_REALPART (arg);
2877       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2878         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2879       else
2880         return arg;
2881
2882     case IMAGPART_EXPR:
2883       if (TREE_CODE (arg) == COMPLEX_CST)
2884         return TREE_IMAGPART (arg);
2885       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2886         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2887       else
2888         return convert (TREE_TYPE (arg), integer_zero_node);
2889
2890     case PREINCREMENT_EXPR:
2891     case POSTINCREMENT_EXPR:
2892     case PREDECREMENT_EXPR:
2893     case POSTDECREMENT_EXPR:
2894       /* Handle complex lvalues (when permitted)
2895          by reduction to simpler cases.  */
2896
2897       val = unary_complex_lvalue (code, arg);
2898       if (val != 0)
2899         return val;
2900
2901       /* Increment or decrement the real part of the value,
2902          and don't change the imaginary part.  */
2903       if (typecode == COMPLEX_TYPE)
2904         {
2905           tree real, imag;
2906
2907           if (pedantic)
2908             pedwarn ("ISO C does not support `++' and `--' on complex types");
2909
2910           arg = stabilize_reference (arg);
2911           real = build_unary_op (REALPART_EXPR, arg, 1);
2912           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2913           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2914                         build_unary_op (code, real, 1), imag);
2915         }
2916
2917       /* Report invalid types.  */
2918
2919       if (typecode != POINTER_TYPE
2920           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2921         {
2922           error ("wrong type argument to %s",
2923                  code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2924                  ? "increment" : "decrement");
2925           return error_mark_node;
2926         }
2927
2928       {
2929         tree inc;
2930         tree result_type = TREE_TYPE (arg);
2931
2932         arg = get_unwidened (arg, 0);
2933         argtype = TREE_TYPE (arg);
2934
2935         /* Compute the increment.  */
2936
2937         if (typecode == POINTER_TYPE)
2938           {
2939             /* If pointer target is an undefined struct,
2940                we just cannot know how to do the arithmetic.  */
2941             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2942               error ("%s of pointer to unknown structure",
2943                      code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2944                      ? "increment" : "decrement");
2945             else if ((pedantic || warn_pointer_arith)
2946                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2947                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2948               pedwarn ("wrong type argument to %s",
2949                        code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2950                        ? "increment" : "decrement");
2951             inc = c_size_in_bytes (TREE_TYPE (result_type));
2952           }
2953         else
2954           inc = integer_one_node;
2955
2956         inc = convert (argtype, inc);
2957
2958         /* Handle incrementing a cast-expression.  */
2959
2960         while (1)
2961           switch (TREE_CODE (arg))
2962             {
2963             case NOP_EXPR:
2964             case CONVERT_EXPR:
2965             case FLOAT_EXPR:
2966             case FIX_TRUNC_EXPR:
2967             case FIX_FLOOR_EXPR:
2968             case FIX_ROUND_EXPR:
2969             case FIX_CEIL_EXPR:
2970               pedantic_lvalue_warning (CONVERT_EXPR);
2971               /* If the real type has the same machine representation
2972                  as the type it is cast to, we can make better output
2973                  by adding directly to the inside of the cast.  */
2974               if ((TREE_CODE (TREE_TYPE (arg))
2975                    == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2976                   && (TYPE_MODE (TREE_TYPE (arg))
2977                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2978                 arg = TREE_OPERAND (arg, 0);
2979               else
2980                 {
2981                   tree incremented, modify, value;
2982                   if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2983                     value = boolean_increment (code, arg);
2984                   else
2985                     {
2986                       arg = stabilize_reference (arg);
2987                       if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2988                         value = arg;
2989                       else
2990                         value = save_expr (arg);
2991                       incremented = build (((code == PREINCREMENT_EXPR
2992                                              || code == POSTINCREMENT_EXPR)
2993                                             ? PLUS_EXPR : MINUS_EXPR),
2994                                            argtype, value, inc);
2995                       TREE_SIDE_EFFECTS (incremented) = 1;
2996                       modify = build_modify_expr (arg, NOP_EXPR, incremented);
2997                       value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2998                     }
2999                   TREE_USED (value) = 1;
3000                   return value;
3001                 }
3002               break;
3003
3004             default:
3005               goto give_up;
3006             }
3007       give_up:
3008
3009         /* Complain about anything else that is not a true lvalue.  */
3010         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3011                                     || code == POSTINCREMENT_EXPR)
3012                                    ? "invalid lvalue in increment"
3013                                    : "invalid lvalue in decrement")))
3014           return error_mark_node;
3015
3016         /* Report a read-only lvalue.  */
3017         if (TREE_READONLY (arg))
3018           readonly_warning (arg,
3019                             ((code == PREINCREMENT_EXPR
3020                               || code == POSTINCREMENT_EXPR)
3021                              ? "increment" : "decrement"));
3022
3023         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3024           val = boolean_increment (code, arg);
3025         else
3026           val = build (code, TREE_TYPE (arg), arg, inc);
3027         TREE_SIDE_EFFECTS (val) = 1;
3028         val = convert (result_type, val);
3029         if (TREE_CODE (val) != code)
3030           TREE_NO_UNUSED_WARNING (val) = 1;
3031         return val;
3032       }
3033
3034     case ADDR_EXPR:
3035       /* Note that this operation never does default_conversion
3036          regardless of NOCONVERT.  */
3037
3038       /* Let &* cancel out to simplify resulting code.  */
3039       if (TREE_CODE (arg) == INDIRECT_REF)
3040         {
3041           /* Don't let this be an lvalue.  */
3042           if (lvalue_p (TREE_OPERAND (arg, 0)))
3043             return non_lvalue (TREE_OPERAND (arg, 0));
3044           return TREE_OPERAND (arg, 0);
3045         }
3046
3047       /* For &x[y], return x+y */
3048       if (TREE_CODE (arg) == ARRAY_REF)
3049         {
3050           if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3051             return error_mark_node;
3052           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3053                                   TREE_OPERAND (arg, 1), 1);
3054         }
3055
3056       /* Handle complex lvalues (when permitted)
3057          by reduction to simpler cases.  */
3058       val = unary_complex_lvalue (code, arg);
3059       if (val != 0)
3060         return val;
3061
3062 #if 0 /* Turned off because inconsistent;
3063          float f; *&(int)f = 3.4 stores in int format
3064          whereas (int)f = 3.4 stores in float format.  */
3065       /* Address of a cast is just a cast of the address
3066          of the operand of the cast.  */
3067       switch (TREE_CODE (arg))
3068         {
3069         case NOP_EXPR:
3070         case CONVERT_EXPR:
3071         case FLOAT_EXPR:
3072         case FIX_TRUNC_EXPR:
3073         case FIX_FLOOR_EXPR:
3074         case FIX_ROUND_EXPR:
3075         case FIX_CEIL_EXPR:
3076           if (pedantic)
3077             pedwarn ("ISO C forbids the address of a cast expression");
3078           return convert (build_pointer_type (TREE_TYPE (arg)),
3079                           build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3080                                           0));
3081         }
3082 #endif
3083
3084       /* Allow the address of a constructor if all the elements
3085          are constant.  */
3086       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3087         ;
3088       /* Anything not already handled and not a true memory reference
3089          is an error.  */
3090       else if (typecode != FUNCTION_TYPE
3091                && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3092         return error_mark_node;
3093
3094       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
3095       argtype = TREE_TYPE (arg);
3096
3097       /* If the lvalue is const or volatile, merge that into the type
3098          to which the address will point.  Note that you can't get a
3099          restricted pointer by taking the address of something, so we
3100          only have to deal with `const' and `volatile' here.  */
3101       if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3102           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3103           argtype = c_build_type_variant (argtype,
3104                                           TREE_READONLY (arg),
3105                                           TREE_THIS_VOLATILE (arg));
3106
3107       argtype = build_pointer_type (argtype);
3108
3109       if (mark_addressable (arg) == 0)
3110         return error_mark_node;
3111
3112       {
3113         tree addr;
3114
3115         if (TREE_CODE (arg) == COMPONENT_REF)
3116           {
3117             tree field = TREE_OPERAND (arg, 1);
3118
3119             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3120
3121             if (DECL_C_BIT_FIELD (field))
3122               {
3123                 error ("attempt to take address of bit-field structure member `%s'",
3124                        IDENTIFIER_POINTER (DECL_NAME (field)));
3125                 return error_mark_node;
3126               }
3127
3128             addr = fold (build (PLUS_EXPR, argtype,
3129                                 convert (argtype, addr),
3130                                 convert (argtype, byte_position (field))));
3131           }
3132         else
3133           addr = build1 (code, argtype, arg);
3134
3135         /* Address of a static or external variable or
3136            file-scope function counts as a constant.  */
3137         if (staticp (arg)
3138             && ! (TREE_CODE (arg) == FUNCTION_DECL
3139                   && DECL_CONTEXT (arg) != 0))
3140           TREE_CONSTANT (addr) = 1;
3141         return addr;
3142       }
3143
3144     default:
3145       break;
3146     }
3147
3148   if (argtype == 0)
3149     argtype = TREE_TYPE (arg);
3150   return fold (build1 (code, argtype, arg));
3151 }
3152
3153 #if 0
3154 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3155    convert ARG with the same conversions in the same order
3156    and return the result.  */
3157
3158 static tree
3159 convert_sequence (conversions, arg)
3160      tree conversions;
3161      tree arg;
3162 {
3163   switch (TREE_CODE (conversions))
3164     {
3165     case NOP_EXPR:
3166     case CONVERT_EXPR:
3167     case FLOAT_EXPR:
3168     case FIX_TRUNC_EXPR:
3169     case FIX_FLOOR_EXPR:
3170     case FIX_ROUND_EXPR:
3171     case FIX_CEIL_EXPR:
3172       return convert (TREE_TYPE (conversions),
3173                       convert_sequence (TREE_OPERAND (conversions, 0),
3174                                         arg));
3175
3176     default:
3177       return arg;
3178     }
3179 }
3180 #endif /* 0 */
3181
3182 /* Return nonzero if REF is an lvalue valid for this language.
3183    Lvalues can be assigned, unless their type has TYPE_READONLY.
3184    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
3185
3186 int
3187 lvalue_p (ref)
3188      tree ref;
3189 {
3190   enum tree_code code = TREE_CODE (ref);
3191
3192   switch (code)
3193     {
3194     case REALPART_EXPR:
3195     case IMAGPART_EXPR:
3196     case COMPONENT_REF:
3197       return lvalue_p (TREE_OPERAND (ref, 0));
3198
3199     case STRING_CST:
3200       return 1;
3201
3202     case INDIRECT_REF:
3203     case ARRAY_REF:
3204     case VAR_DECL:
3205     case PARM_DECL:
3206     case RESULT_DECL:
3207     case ERROR_MARK:
3208       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3209               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3210
3211     case BIND_EXPR:
3212     case RTL_EXPR:
3213       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3214
3215     default:
3216       return 0;
3217     }
3218 }
3219
3220 /* Return nonzero if REF is an lvalue valid for this language;
3221    otherwise, print an error message and return zero.  */
3222
3223 int
3224 lvalue_or_else (ref, msgid)
3225      tree ref;
3226      const char *msgid;
3227 {
3228   int win = lvalue_p (ref);
3229
3230   if (! win)
3231     error ("%s", msgid);
3232
3233   return win;
3234 }
3235
3236 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3237    for certain kinds of expressions which are not really lvalues
3238    but which we can accept as lvalues.
3239
3240    If ARG is not a kind of expression we can handle, return zero.  */
3241
3242 static tree
3243 unary_complex_lvalue (code, arg)
3244      enum tree_code code;
3245      tree arg;
3246 {
3247   /* Handle (a, b) used as an "lvalue".  */
3248   if (TREE_CODE (arg) == COMPOUND_EXPR)
3249     {
3250       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3251
3252       /* If this returns a function type, it isn't really being used as
3253          an lvalue, so don't issue a warning about it.  */
3254       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3255         pedantic_lvalue_warning (COMPOUND_EXPR);
3256
3257       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3258                     TREE_OPERAND (arg, 0), real_result);
3259     }
3260
3261   /* Handle (a ? b : c) used as an "lvalue".  */
3262   if (TREE_CODE (arg) == COND_EXPR)
3263     {
3264       pedantic_lvalue_warning (COND_EXPR);
3265       if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3266         pedantic_lvalue_warning (COMPOUND_EXPR);
3267
3268       return (build_conditional_expr
3269               (TREE_OPERAND (arg, 0),
3270                build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3271                build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3272     }
3273
3274   return 0;
3275 }
3276
3277 /* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
3278    COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
3279
3280 static void
3281 pedantic_lvalue_warning (code)
3282      enum tree_code code;
3283 {
3284   if (pedantic)
3285     switch (code)
3286       {
3287       case COND_EXPR:
3288         pedwarn ("ISO C forbids use of conditional expressions as lvalues");
3289         break;
3290       case COMPOUND_EXPR:
3291         pedwarn ("ISO C forbids use of compound expressions as lvalues");
3292         break;
3293       default:
3294         pedwarn ("ISO C forbids use of cast expressions as lvalues");
3295         break;
3296       }
3297 }
3298 \f
3299 /* Warn about storing in something that is `const'.  */
3300
3301 void
3302 readonly_warning (arg, msgid)
3303      tree arg;
3304      const char *msgid;
3305 {
3306   if (TREE_CODE (arg) == COMPONENT_REF)
3307     {
3308       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3309         readonly_warning (TREE_OPERAND (arg, 0), msgid);
3310       else
3311         pedwarn ("%s of read-only member `%s'", _(msgid),
3312                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3313     }
3314   else if (TREE_CODE (arg) == VAR_DECL)
3315     pedwarn ("%s of read-only variable `%s'", _(msgid),
3316              IDENTIFIER_POINTER (DECL_NAME (arg)));
3317   else
3318     pedwarn ("%s of read-only location", _(msgid));
3319 }
3320 \f
3321 /* Mark EXP saying that we need to be able to take the
3322    address of it; it should not be allocated in a register.
3323    Value is 1 if successful.  */
3324
3325 int
3326 mark_addressable (exp)
3327      tree exp;
3328 {
3329   tree x = exp;
3330   while (1)
3331     switch (TREE_CODE (x))
3332       {
3333       case COMPONENT_REF:
3334         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3335           {
3336             error ("cannot take address of bitfield `%s'",
3337                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3338             return 0;
3339           }
3340
3341         /* ... fall through ...  */
3342
3343       case ADDR_EXPR:
3344       case ARRAY_REF:
3345       case REALPART_EXPR:
3346       case IMAGPART_EXPR:
3347         x = TREE_OPERAND (x, 0);
3348         break;
3349
3350       case CONSTRUCTOR:
3351         TREE_ADDRESSABLE (x) = 1;
3352         return 1;
3353
3354       case VAR_DECL:
3355       case CONST_DECL:
3356       case PARM_DECL:
3357       case RESULT_DECL:
3358         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3359             && DECL_NONLOCAL (x))
3360           {
3361             if (TREE_PUBLIC (x))
3362               {
3363                 error ("global register variable `%s' used in nested function",
3364                        IDENTIFIER_POINTER (DECL_NAME (x)));
3365                 return 0;
3366               }
3367             pedwarn ("register variable `%s' used in nested function",
3368                      IDENTIFIER_POINTER (DECL_NAME (x)));
3369           }
3370         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3371           {
3372             if (TREE_PUBLIC (x))
3373               {
3374                 error ("address of global register variable `%s' requested",
3375                        IDENTIFIER_POINTER (DECL_NAME (x)));
3376                 return 0;
3377               }
3378
3379             /* If we are making this addressable due to its having
3380                volatile components, give a different error message.  Also
3381                handle the case of an unnamed parameter by not trying
3382                to give the name.  */
3383
3384             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3385               {
3386                 error ("cannot put object with volatile field into register");
3387                 return 0;
3388               }
3389
3390             pedwarn ("address of register variable `%s' requested",
3391                      IDENTIFIER_POINTER (DECL_NAME (x)));
3392           }
3393         put_var_into_stack (x);
3394
3395         /* drops in */
3396       case FUNCTION_DECL:
3397         TREE_ADDRESSABLE (x) = 1;
3398 #if 0  /* poplevel deals with this now.  */
3399         if (DECL_CONTEXT (x) == 0)
3400           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3401 #endif
3402
3403       default:
3404         return 1;
3405     }
3406 }
3407 \f
3408 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3409
3410 tree
3411 build_conditional_expr (ifexp, op1, op2)
3412      tree ifexp, op1, op2;
3413 {
3414   tree type1;
3415   tree type2;
3416   enum tree_code code1;
3417   enum tree_code code2;
3418   tree result_type = NULL;
3419   tree orig_op1 = op1, orig_op2 = op2;
3420
3421   ifexp = truthvalue_conversion (default_conversion (ifexp));
3422
3423 #if 0 /* Produces wrong result if within sizeof.  */
3424   /* Don't promote the operands separately if they promote
3425      the same way.  Return the unpromoted type and let the combined
3426      value get promoted if necessary.  */
3427
3428   if (TREE_TYPE (op1) == TREE_TYPE (op2)
3429       && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3430       && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3431       && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3432     {
3433       if (TREE_CODE (ifexp) == INTEGER_CST)
3434         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3435
3436       return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3437     }
3438 #endif
3439
3440   /* Promote both alternatives.  */
3441
3442   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3443     op1 = default_conversion (op1);
3444   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3445     op2 = default_conversion (op2);
3446
3447   if (TREE_CODE (ifexp) == ERROR_MARK
3448       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3449       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3450     return error_mark_node;
3451
3452   type1 = TREE_TYPE (op1);
3453   code1 = TREE_CODE (type1);
3454   type2 = TREE_TYPE (op2);
3455   code2 = TREE_CODE (type2);
3456
3457   /* Quickly detect the usual case where op1 and op2 have the same type
3458      after promotion.  */
3459   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3460     {
3461       if (type1 == type2)
3462         result_type = type1;
3463       else
3464         result_type = TYPE_MAIN_VARIANT (type1);
3465     }
3466   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3467             || code1 == COMPLEX_TYPE)
3468            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3469                || code2 == COMPLEX_TYPE))
3470     {
3471       result_type = common_type (type1, type2);
3472
3473       /* If -Wsign-compare, warn here if type1 and type2 have
3474          different signedness.  We'll promote the signed to unsigned
3475          and later code won't know it used to be different.
3476          Do this check on the original types, so that explicit casts
3477          will be considered, but default promotions won't.  */
3478       if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare)
3479           && !skip_evaluation)
3480         {
3481           int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
3482           int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
3483
3484           if (unsigned_op1 ^ unsigned_op2)
3485             {
3486               /* Do not warn if the result type is signed, since the
3487                  signed type will only be chosen if it can represent
3488                  all the values of the unsigned type.  */
3489               if (! TREE_UNSIGNED (result_type))
3490                 /* OK */;
3491               /* Do not warn if the signed quantity is an unsuffixed
3492                  integer literal (or some static constant expression
3493                  involving such literals) and it is non-negative.  */
3494               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3495                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3496                 /* OK */;
3497               else
3498                 warning ("signed and unsigned type in conditional expression");
3499             }
3500         }
3501     }
3502   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3503     {
3504       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3505         pedwarn ("ISO C forbids conditional expr with only one void side");
3506       result_type = void_type_node;
3507     }
3508   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3509     {
3510       if (comp_target_types (type1, type2))
3511         result_type = common_type (type1, type2);
3512       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3513                && TREE_CODE (orig_op1) != NOP_EXPR)
3514         result_type = qualify_type (type2, type1);
3515       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3516                && TREE_CODE (orig_op2) != NOP_EXPR)
3517         result_type = qualify_type (type1, type2);
3518       else if (VOID_TYPE_P (TREE_TYPE (type1)))
3519         {
3520           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3521             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3522           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3523                                                           TREE_TYPE (type2)));
3524         }
3525       else if (VOID_TYPE_P (TREE_TYPE (type2)))
3526         {
3527           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3528             pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
3529           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3530                                                           TREE_TYPE (type1)));
3531         }
3532       else
3533         {
3534           pedwarn ("pointer type mismatch in conditional expression");
3535           result_type = build_pointer_type (void_type_node);
3536         }
3537     }
3538   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3539     {
3540       if (! integer_zerop (op2))
3541         pedwarn ("pointer/integer type mismatch in conditional expression");
3542       else
3543         {
3544           op2 = null_pointer_node;
3545         }
3546       result_type = type1;
3547     }
3548   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3549     {
3550       if (!integer_zerop (op1))
3551         pedwarn ("pointer/integer type mismatch in conditional expression");
3552       else
3553         {
3554           op1 = null_pointer_node;
3555         }
3556       result_type = type2;
3557     }
3558
3559   if (!result_type)
3560     {
3561       if (flag_cond_mismatch)
3562         result_type = void_type_node;
3563       else
3564         {
3565           error ("type mismatch in conditional expression");
3566           return error_mark_node;
3567         }
3568     }
3569
3570   /* Merge const and volatile flags of the incoming types.  */
3571   result_type
3572     = build_type_variant (result_type,
3573                           TREE_READONLY (op1) || TREE_READONLY (op2),
3574                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3575
3576   if (result_type != TREE_TYPE (op1))
3577     op1 = convert_and_check (result_type, op1);
3578   if (result_type != TREE_TYPE (op2))
3579     op2 = convert_and_check (result_type, op2);
3580
3581   if (TREE_CODE (ifexp) == INTEGER_CST)
3582     return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3583
3584   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3585 }
3586 \f
3587 /* Given a list of expressions, return a compound expression
3588    that performs them all and returns the value of the last of them.  */
3589
3590 tree
3591 build_compound_expr (list)
3592      tree list;
3593 {
3594   return internal_build_compound_expr (list, TRUE);
3595 }
3596
3597 static tree
3598 internal_build_compound_expr (list, first_p)
3599      tree list;
3600      int first_p;
3601 {
3602   tree rest;
3603
3604   if (TREE_CHAIN (list) == 0)
3605     {
3606       /* Convert arrays to pointers when there really is a comma operator.  */
3607       if (!first_p && TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
3608         TREE_VALUE (list) = default_conversion (TREE_VALUE (list));
3609
3610 #if 0 /* If something inside inhibited lvalueness, we should not override.  */
3611       /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
3612
3613       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3614       if (TREE_CODE (list) == NON_LVALUE_EXPR)
3615         list = TREE_OPERAND (list, 0);
3616 #endif
3617
3618       /* Don't let (0, 0) be null pointer constant.  */
3619       if (!first_p && integer_zerop (TREE_VALUE (list)))
3620         return non_lvalue (TREE_VALUE (list));
3621       return TREE_VALUE (list);
3622     }
3623
3624   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3625
3626   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3627     {
3628       /* The left-hand operand of a comma expression is like an expression
3629          statement: with -W or -Wunused, we should warn if it doesn't have
3630          any side-effects, unless it was explicitly cast to (void).  */
3631       if ((extra_warnings || warn_unused_value)
3632            && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3633                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
3634         warning ("left-hand operand of comma expression has no effect");
3635
3636       /* When pedantic, a compound expression can be neither an lvalue
3637          nor an integer constant expression.  */
3638       if (! pedantic)
3639         return rest;
3640     }
3641
3642   /* With -Wunused, we should also warn if the left-hand operand does have
3643      side-effects, but computes a value which is not used.  For example, in
3644      `foo() + bar(), baz()' the result of the `+' operator is not used,
3645      so we should issue a warning.  */
3646   else if (warn_unused_value)
3647     warn_if_unused_value (TREE_VALUE (list));
3648
3649   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3650 }
3651
3652 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3653
3654 tree
3655 build_c_cast (type, expr)
3656      tree type;
3657      tree expr;
3658 {
3659   tree value = expr;
3660
3661   if (type == error_mark_node || expr == error_mark_node)
3662     return error_mark_node;
3663   type = TYPE_MAIN_VARIANT (type);
3664
3665 #if 0
3666   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3667   if (TREE_CODE (value) == NON_LVALUE_EXPR)
3668     value = TREE_OPERAND (value, 0);
3669 #endif
3670
3671   if (TREE_CODE (type) == ARRAY_TYPE)
3672     {
3673       error ("cast specifies array type");
3674       return error_mark_node;
3675     }
3676
3677   if (TREE_CODE (type) == FUNCTION_TYPE)
3678     {
3679       error ("cast specifies function type");
3680       return error_mark_node;
3681     }
3682
3683   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3684     {
3685       if (pedantic)
3686         {
3687           if (TREE_CODE (type) == RECORD_TYPE
3688               || TREE_CODE (type) == UNION_TYPE)
3689             pedwarn ("ISO C forbids casting nonscalar to the same type");
3690         }
3691     }
3692   else if (TREE_CODE (type) == UNION_TYPE)
3693     {
3694       tree field;
3695       if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3696           || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3697         value = default_conversion (value);
3698
3699       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3700         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3701                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3702           break;
3703
3704       if (field)
3705         {
3706           const char *name;
3707           tree t;
3708
3709           if (pedantic)
3710             pedwarn ("ISO C forbids casts to union type");
3711           if (TYPE_NAME (type) != 0)
3712             {
3713               if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3714                 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3715               else
3716                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3717             }
3718           else
3719             name = "";
3720           t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3721                                         build_tree_list (field, value)),
3722                            0, 0);
3723           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3724           return t;
3725         }
3726       error ("cast to union type from type not present in union");
3727       return error_mark_node;
3728     }
3729   else
3730     {
3731       tree otype, ovalue;
3732
3733       /* If casting to void, avoid the error that would come
3734          from default_conversion in the case of a non-lvalue array.  */
3735       if (type == void_type_node)
3736         return build1 (CONVERT_EXPR, type, value);
3737
3738       /* Convert functions and arrays to pointers,
3739          but don't convert any other types.  */
3740       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3741           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3742         value = default_conversion (value);
3743       otype = TREE_TYPE (value);
3744
3745       /* Optionally warn about potentially worrisome casts.  */
3746
3747       if (warn_cast_qual
3748           && TREE_CODE (type) == POINTER_TYPE
3749           && TREE_CODE (otype) == POINTER_TYPE)
3750         {
3751           tree in_type = type;
3752           tree in_otype = otype;
3753           int warn = 0;
3754
3755           /* Check that the qualifiers on IN_TYPE are a superset of
3756              the qualifiers of IN_OTYPE.  The outermost level of
3757              POINTER_TYPE nodes is uninteresting and we stop as soon
3758              as we hit a non-POINTER_TYPE node on either type.  */
3759           do
3760             {
3761               in_otype = TREE_TYPE (in_otype);
3762               in_type = TREE_TYPE (in_type);
3763               warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3764             }
3765           while (TREE_CODE (in_type) == POINTER_TYPE
3766                  && TREE_CODE (in_otype) == POINTER_TYPE);
3767
3768           if (warn)
3769             /* There are qualifiers present in IN_OTYPE that are not
3770                present in IN_TYPE.  */
3771             warning ("cast discards qualifiers from pointer target type");
3772         }
3773
3774       /* Warn about possible alignment problems.  */
3775       if (STRICT_ALIGNMENT && warn_cast_align
3776           && TREE_CODE (type) == POINTER_TYPE
3777           && TREE_CODE (otype) == POINTER_TYPE
3778           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3779           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3780           /* Don't warn about opaque types, where the actual alignment
3781              restriction is unknown.  */
3782           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3783                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3784                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3785           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3786         warning ("cast increases required alignment of target type");
3787
3788       if (TREE_CODE (type) == INTEGER_TYPE
3789           && TREE_CODE (otype) == POINTER_TYPE
3790           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3791           && !TREE_CONSTANT (value))
3792         warning ("cast from pointer to integer of different size");
3793
3794       if (warn_bad_function_cast
3795           && TREE_CODE (value) == CALL_EXPR
3796           && TREE_CODE (type) != TREE_CODE (otype))
3797         warning ("cast does not match function type");
3798
3799       if (TREE_CODE (type) == POINTER_TYPE
3800           && TREE_CODE (otype) == INTEGER_TYPE
3801           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3802           /* Don't warn about converting any constant.  */
3803           && !TREE_CONSTANT (value))
3804         warning ("cast to pointer from integer of different size");
3805
3806       ovalue = value;
3807       value = convert (type, value);
3808
3809       /* Ignore any integer overflow caused by the cast.  */
3810       if (TREE_CODE (value) == INTEGER_CST)
3811         {
3812           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3813           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3814         }
3815     }
3816
3817   /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant.  */
3818   if (pedantic && TREE_CODE (value) == INTEGER_CST
3819       && TREE_CODE (expr) == INTEGER_CST
3820       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3821     value = non_lvalue (value);
3822
3823   /* If pedantic, don't let a cast be an lvalue.  */
3824   if (value == expr && pedantic)
3825     value = non_lvalue (value);
3826
3827   return value;
3828 }
3829
3830 /* Interpret a cast of expression EXPR to type TYPE.  */
3831 tree
3832 c_cast_expr (type, expr)
3833      tree type, expr;
3834 {
3835   int saved_wsp = warn_strict_prototypes;
3836
3837   /* This avoids warnings about unprototyped casts on
3838      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3839   if (TREE_CODE (expr) == INTEGER_CST)
3840     warn_strict_prototypes = 0;
3841   type = groktypename (type);
3842   warn_strict_prototypes = saved_wsp;
3843
3844   return build_c_cast (type, expr);
3845 }
3846
3847 \f
3848 /* Build an assignment expression of lvalue LHS from value RHS.
3849    MODIFYCODE is the code for a binary operator that we use
3850    to combine the old value of LHS with RHS to get the new value.
3851    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3852
3853 tree
3854 build_modify_expr (lhs, modifycode, rhs)
3855      tree lhs, rhs;
3856      enum tree_code modifycode;
3857 {
3858   tree result;
3859   tree newrhs;
3860   tree lhstype = TREE_TYPE (lhs);
3861   tree olhstype = lhstype;
3862
3863   /* Types that aren't fully specified cannot be used in assignments.  */
3864   lhs = require_complete_type (lhs);
3865
3866   /* Avoid duplicate error messages from operands that had errors.  */
3867   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3868     return error_mark_node;
3869
3870   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3871   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3872      whose value is 0 to count as a null pointer constant.  */
3873   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3874     rhs = TREE_OPERAND (rhs, 0);
3875
3876   newrhs = rhs;
3877
3878   /* Handle control structure constructs used as "lvalues".  */
3879
3880   switch (TREE_CODE (lhs))
3881     {
3882       /* Handle (a, b) used as an "lvalue".  */
3883     case COMPOUND_EXPR:
3884       pedantic_lvalue_warning (COMPOUND_EXPR);
3885       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3886       if (TREE_CODE (newrhs) == ERROR_MARK)
3887         return error_mark_node;
3888       return build (COMPOUND_EXPR, lhstype,
3889                     TREE_OPERAND (lhs, 0), newrhs);
3890
3891       /* Handle (a ? b : c) used as an "lvalue".  */
3892     case COND_EXPR:
3893       pedantic_lvalue_warning (COND_EXPR);
3894       rhs = save_expr (rhs);
3895       {
3896         /* Produce (a ? (b = rhs) : (c = rhs))
3897            except that the RHS goes through a save-expr
3898            so the code to compute it is only emitted once.  */
3899         tree cond
3900           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3901                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3902                                                        modifycode, rhs),
3903                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3904                                                        modifycode, rhs));
3905         if (TREE_CODE (cond) == ERROR_MARK)
3906           return cond;
3907         /* Make sure the code to compute the rhs comes out
3908            before the split.  */
3909         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3910                       /* But cast it to void to avoid an "unused" error.  */
3911                       convert (void_type_node, rhs), cond);
3912       }
3913     default:
3914       break;
3915     }
3916
3917   /* If a binary op has been requested, combine the old LHS value with the RHS
3918      producing the value we should actually store into the LHS.  */
3919
3920   if (modifycode != NOP_EXPR)
3921     {
3922       lhs = stabilize_reference (lhs);
3923       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3924     }
3925
3926   /* Handle a cast used as an "lvalue".
3927      We have already performed any binary operator using the value as cast.
3928      Now convert the result to the cast type of the lhs,
3929      and then true type of the lhs and store it there;
3930      then convert result back to the cast type to be the value
3931      of the assignment.  */
3932
3933   switch (TREE_CODE (lhs))
3934     {
3935     case NOP_EXPR:
3936     case CONVERT_EXPR:
3937     case FLOAT_EXPR:
3938     case FIX_TRUNC_EXPR:
3939     case FIX_FLOOR_EXPR:
3940     case FIX_ROUND_EXPR:
3941     case FIX_CEIL_EXPR:
3942       if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3943           || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3944         newrhs = default_conversion (newrhs);
3945       {
3946         tree inner_lhs = TREE_OPERAND (lhs, 0);
3947         tree result;
3948         result = build_modify_expr (inner_lhs, NOP_EXPR,
3949                                     convert (TREE_TYPE (inner_lhs),
3950                                              convert (lhstype, newrhs)));
3951         if (TREE_CODE (result) == ERROR_MARK)
3952           return result;
3953         pedantic_lvalue_warning (CONVERT_EXPR);
3954         return convert (TREE_TYPE (lhs), result);
3955       }
3956
3957     default:
3958       break;
3959     }
3960
3961   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3962      Reject anything strange now.  */
3963
3964   if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3965     return error_mark_node;
3966
3967   /* Warn about storing in something that is `const'.  */
3968
3969   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3970       || ((TREE_CODE (lhstype) == RECORD_TYPE
3971            || TREE_CODE (lhstype) == UNION_TYPE)
3972           && C_TYPE_FIELDS_READONLY (lhstype)))
3973     readonly_warning (lhs, "assignment");
3974
3975   /* If storing into a structure or union member,
3976      it has probably been given type `int'.
3977      Compute the type that would go with
3978      the actual amount of storage the member occupies.  */
3979
3980   if (TREE_CODE (lhs) == COMPONENT_REF
3981       && (TREE_CODE (lhstype) == INTEGER_TYPE
3982           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3983           || TREE_CODE (lhstype) == REAL_TYPE
3984           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3985     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3986
3987   /* If storing in a field that is in actuality a short or narrower than one,
3988      we must store in the field in its actual type.  */
3989
3990   if (lhstype != TREE_TYPE (lhs))
3991     {
3992       lhs = copy_node (lhs);
3993       TREE_TYPE (lhs) = lhstype;
3994     }
3995
3996   /* Convert new value to destination type.  */
3997
3998   newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3999                                    NULL_TREE, NULL_TREE, 0);
4000   if (TREE_CODE (newrhs) == ERROR_MARK)
4001     return error_mark_node;
4002
4003   /* Scan operands */
4004
4005   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4006   TREE_SIDE_EFFECTS (result) = 1;
4007
4008   /* If we got the LHS in a different type for storing in,
4009      convert the result back to the nominal type of LHS
4010      so that the value we return always has the same type
4011      as the LHS argument.  */
4012
4013   if (olhstype == TREE_TYPE (result))
4014     return result;
4015   return convert_for_assignment (olhstype, result, _("assignment"),
4016                                  NULL_TREE, NULL_TREE, 0);
4017 }
4018 \f
4019 /* Convert value RHS to type TYPE as preparation for an assignment
4020    to an lvalue of type TYPE.
4021    The real work of conversion is done by `convert'.
4022    The purpose of this function is to generate error messages
4023    for assignments that are not allowed in C.
4024    ERRTYPE is a string to use in error messages:
4025    "assignment", "return", etc.  If it is null, this is parameter passing
4026    for a function call (and different error messages are output).
4027
4028    FUNNAME is the name of the function being called,
4029    as an IDENTIFIER_NODE, or null.
4030    PARMNUM is the number of the argument, for printing in error messages.  */
4031
4032 static tree
4033 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4034      tree type, rhs;
4035      const char *errtype;
4036      tree fundecl, funname;
4037      int parmnum;
4038 {
4039   enum tree_code codel = TREE_CODE (type);
4040   tree rhstype;
4041   enum tree_code coder;
4042
4043   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4044   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4045      whose value is 0 to count as a null pointer constant.  */
4046   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4047     rhs = TREE_OPERAND (rhs, 0);
4048
4049   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4050       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4051     rhs = default_conversion (rhs);
4052   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4053     rhs = decl_constant_value_for_broken_optimization (rhs);
4054
4055   rhstype = TREE_TYPE (rhs);
4056   coder = TREE_CODE (rhstype);
4057
4058   if (coder == ERROR_MARK)
4059     return error_mark_node;
4060
4061   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4062     {
4063       overflow_warning (rhs);
4064       /* Check for Objective-C protocols.  This will issue a warning if
4065          there are protocol violations.  No need to use the return value.  */
4066       maybe_objc_comptypes (type, rhstype, 0);
4067       return rhs;
4068     }
4069
4070   if (coder == VOID_TYPE)
4071     {
4072       error ("void value not ignored as it ought to be");
4073       return error_mark_node;
4074     }
4075   /* A type converts to a reference to it.
4076      This code doesn't fully support references, it's just for the
4077      special case of va_start and va_copy.  */
4078   if (codel == REFERENCE_TYPE
4079       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4080     {
4081       if (mark_addressable (rhs) == 0)
4082         return error_mark_node;
4083       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4084
4085       /* We already know that these two types are compatible, but they
4086          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
4087          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4088          likely to be va_list, a typedef to __builtin_va_list, which
4089          is different enough that it will cause problems later.  */
4090       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4091         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4092
4093       rhs = build1 (NOP_EXPR, type, rhs);
4094       return rhs;
4095     }
4096   /* Arithmetic types all interconvert, and enum is treated like int.  */
4097   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4098             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4099             || codel == BOOLEAN_TYPE)
4100            && (coder == INTEGER_TYPE || coder == REAL_TYPE
4101                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4102                || coder == BOOLEAN_TYPE))
4103     return convert_and_check (type, rhs);
4104
4105   /* Conversion to a transparent union from its member types.
4106      This applies only to function arguments.  */
4107   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4108     {
4109       tree memb_types;
4110       tree marginal_memb_type = 0;
4111
4112       for (memb_types = TYPE_FIELDS (type); memb_types;
4113            memb_types = TREE_CHAIN (memb_types))
4114         {
4115           tree memb_type = TREE_TYPE (memb_types);
4116
4117           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4118                          TYPE_MAIN_VARIANT (rhstype)))
4119             break;
4120
4121           if (TREE_CODE (memb_type) != POINTER_TYPE)
4122             continue;
4123
4124           if (coder == POINTER_TYPE)
4125             {
4126               tree ttl = TREE_TYPE (memb_type);
4127               tree ttr = TREE_TYPE (rhstype);
4128
4129               /* Any non-function converts to a [const][volatile] void *
4130                  and vice versa; otherwise, targets must be the same.
4131                  Meanwhile, the lhs target must have all the qualifiers of
4132                  the rhs.  */
4133               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4134                   || comp_target_types (memb_type, rhstype))
4135                 {
4136                   /* If this type won't generate any warnings, use it.  */
4137                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4138                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4139                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4140                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4141                              == TYPE_QUALS (ttr))
4142                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4143                              == TYPE_QUALS (ttl))))
4144                     break;
4145
4146                   /* Keep looking for a better type, but remember this one.  */
4147                   if (! marginal_memb_type)
4148                     marginal_memb_type = memb_type;
4149                 }
4150             }
4151
4152           /* Can convert integer zero to any pointer type.  */
4153           if (integer_zerop (rhs)
4154               || (TREE_CODE (rhs) == NOP_EXPR
4155                   && integer_zerop (TREE_OPERAND (rhs, 0))))
4156             {
4157               rhs = null_pointer_node;
4158               break;
4159             }
4160         }
4161
4162       if (memb_types || marginal_memb_type)
4163         {
4164           if (! memb_types)
4165             {
4166               /* We have only a marginally acceptable member type;
4167                  it needs a warning.  */
4168               tree ttl = TREE_TYPE (marginal_memb_type);
4169               tree ttr = TREE_TYPE (rhstype);
4170
4171               /* Const and volatile mean something different for function
4172                  types, so the usual warnings are not appropriate.  */
4173               if (TREE_CODE (ttr) == FUNCTION_TYPE
4174                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4175                 {
4176                   /* Because const and volatile on functions are
4177                      restrictions that say the function will not do
4178                      certain things, it is okay to use a const or volatile
4179                      function where an ordinary one is wanted, but not
4180                      vice-versa.  */
4181                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4182                     warn_for_assignment ("%s makes qualified function pointer from unqualified",
4183                                          errtype, funname, parmnum);
4184                 }
4185               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4186                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4187                                      errtype, funname,
4188                                      parmnum);
4189             }
4190
4191           if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4192             pedwarn ("ISO C prohibits argument conversion to union type");
4193
4194           return build1 (NOP_EXPR, type, rhs);
4195         }
4196     }
4197
4198   /* Conversions among pointers */
4199   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4200            && (coder == POINTER_TYPE || coder == REFERENCE_TYPE))
4201     {
4202       tree ttl = TREE_TYPE (type);
4203       tree ttr = TREE_TYPE (rhstype);
4204
4205       /* Any non-function converts to a [const][volatile] void *
4206          and vice versa; otherwise, targets must be the same.
4207          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4208       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4209           || comp_target_types (type, rhstype)
4210           || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4211               == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4212         {
4213           if (pedantic
4214               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4215                   ||
4216                   (VOID_TYPE_P (ttr)
4217                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
4218                       which are not ANSI null ptr constants.  */
4219                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4220                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4221             warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
4222                                  errtype, funname, parmnum);
4223           /* Const and volatile mean something different for function types,
4224              so the usual warnings are not appropriate.  */
4225           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4226                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4227             {
4228               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4229                 warn_for_assignment ("%s discards qualifiers from pointer target type",
4230                                      errtype, funname, parmnum);
4231               /* If this is not a case of ignoring a mismatch in signedness,
4232                  no warning.  */
4233               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4234                        || comp_target_types (type, rhstype))
4235                 ;
4236               /* If there is a mismatch, do warn.  */
4237               else if (pedantic)
4238                 warn_for_assignment ("pointer targets in %s differ in signedness",
4239                                      errtype, funname, parmnum);
4240             }
4241           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4242                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4243             {
4244               /* Because const and volatile on functions are restrictions
4245                  that say the function will not do certain things,
4246                  it is okay to use a const or volatile function
4247                  where an ordinary one is wanted, but not vice-versa.  */
4248               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4249                 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4250                                      errtype, funname, parmnum);
4251             }
4252         }
4253       else
4254         warn_for_assignment ("%s from incompatible pointer type",
4255                              errtype, funname, parmnum);
4256       return convert (type, rhs);
4257     }
4258   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4259     {
4260       /* An explicit constant 0 can convert to a pointer,
4261          or one that results from arithmetic, even including
4262          a cast to integer type.  */
4263       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4264           &&
4265           ! (TREE_CODE (rhs) == NOP_EXPR
4266              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4267              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4268              && integer_zerop (TREE_OPERAND (rhs, 0))))
4269         {
4270           warn_for_assignment ("%s makes pointer from integer without a cast",
4271                                errtype, funname, parmnum);
4272           return convert (type, rhs);
4273         }
4274       return null_pointer_node;
4275     }
4276   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4277     {
4278       warn_for_assignment ("%s makes integer from pointer without a cast",
4279                            errtype, funname, parmnum);
4280       return convert (type, rhs);
4281     }
4282   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4283     return convert (type, rhs);
4284
4285   if (!errtype)
4286     {
4287       if (funname)
4288         {
4289           tree selector = maybe_building_objc_message_expr ();
4290
4291           if (selector && parmnum > 2)
4292             error ("incompatible type for argument %d of `%s'",
4293                    parmnum - 2, IDENTIFIER_POINTER (selector));
4294           else
4295             error ("incompatible type for argument %d of `%s'",
4296                    parmnum, IDENTIFIER_POINTER (funname));
4297         }
4298       else
4299         error ("incompatible type for argument %d of indirect function call",
4300                parmnum);
4301     }
4302   else
4303     error ("incompatible types in %s", errtype);
4304
4305   return error_mark_node;
4306 }
4307
4308 /* Print a warning using MSGID.
4309    It gets OPNAME as its one parameter.
4310    If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4311    FUNCTION and ARGNUM are handled specially if we are building an
4312    Objective-C selector.  */
4313
4314 static void
4315 warn_for_assignment (msgid, opname, function, argnum)
4316      const char *msgid;
4317      const char *opname;
4318      tree function;
4319      int argnum;
4320 {
4321   if (opname == 0)
4322     {
4323       tree selector = maybe_building_objc_message_expr ();
4324       char * new_opname;
4325
4326       if (selector && argnum > 2)
4327         {
4328           function = selector;
4329           argnum -= 2;
4330         }
4331       if (function)
4332         {
4333           /* Function name is known; supply it.  */
4334           const char *const argstring = _("passing arg %d of `%s'");
4335           new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4336                                         + strlen (argstring) + 1 + 25
4337                                         /*%d*/ + 1);
4338           sprintf (new_opname, argstring, argnum,
4339                    IDENTIFIER_POINTER (function));
4340         }
4341       else
4342         {
4343           /* Function name unknown (call through ptr); just give arg number.*/
4344           const char *const argnofun = _("passing arg %d of pointer to function");
4345           new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4346           sprintf (new_opname, argnofun, argnum);
4347         }
4348       opname = new_opname;
4349     }
4350   pedwarn (msgid, opname);
4351 }
4352 \f
4353 /* If VALUE is a compound expr all of whose expressions are constant, then
4354    return its value.  Otherwise, return error_mark_node.
4355
4356    This is for handling COMPOUND_EXPRs as initializer elements
4357    which is allowed with a warning when -pedantic is specified.  */
4358
4359 static tree
4360 valid_compound_expr_initializer (value, endtype)
4361      tree value;
4362      tree endtype;
4363 {
4364   if (TREE_CODE (value) == COMPOUND_EXPR)
4365     {
4366       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4367           == error_mark_node)
4368         return error_mark_node;
4369       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4370                                               endtype);
4371     }
4372   else if (! TREE_CONSTANT (value)
4373            && ! initializer_constant_valid_p (value, endtype))
4374     return error_mark_node;
4375   else
4376     return value;
4377 }
4378 \f
4379 /* Perform appropriate conversions on the initial value of a variable,
4380    store it in the declaration DECL,
4381    and print any error messages that are appropriate.
4382    If the init is invalid, store an ERROR_MARK.  */
4383
4384 void
4385 store_init_value (decl, init)
4386      tree decl, init;
4387 {
4388   tree value, type;
4389
4390   /* If variable's type was invalidly declared, just ignore it.  */
4391
4392   type = TREE_TYPE (decl);
4393   if (TREE_CODE (type) == ERROR_MARK)
4394     return;
4395
4396   /* Digest the specified initializer into an expression.  */
4397
4398   value = digest_init (type, init, TREE_STATIC (decl),
4399                        TREE_STATIC (decl) || (pedantic && !flag_isoc99));
4400
4401   /* Store the expression if valid; else report error.  */
4402
4403 #if 0
4404   /* Note that this is the only place we can detect the error
4405      in a case such as   struct foo bar = (struct foo) { x, y };
4406      where there is one initial value which is a constructor expression.  */
4407   if (value == error_mark_node)
4408     ;
4409   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4410     {
4411       error ("initializer for static variable is not constant");
4412       value = error_mark_node;
4413     }
4414   else if (TREE_STATIC (decl)
4415            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4416     {
4417       error ("initializer for static variable uses complicated arithmetic");
4418       value = error_mark_node;
4419     }
4420   else
4421     {
4422       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4423         {
4424           if (! TREE_CONSTANT (value))
4425             pedwarn ("aggregate initializer is not constant");
4426           else if (! TREE_STATIC (value))
4427             pedwarn ("aggregate initializer uses complicated arithmetic");
4428         }
4429     }
4430 #endif
4431
4432   if (warn_traditional && !in_system_header
4433       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
4434     warning ("traditional C rejects automatic aggregate initialization");
4435
4436   DECL_INITIAL (decl) = value;
4437
4438   /* ANSI wants warnings about out-of-range constant initializers.  */
4439   STRIP_TYPE_NOPS (value);
4440   constant_expression_warning (value);
4441 }
4442 \f
4443 /* Methods for storing and printing names for error messages.  */
4444
4445 /* Implement a spelling stack that allows components of a name to be pushed
4446    and popped.  Each element on the stack is this structure.  */
4447
4448 struct spelling
4449 {
4450   int kind;
4451   union
4452     {
4453       int i;
4454       const char *s;
4455     } u;
4456 };
4457
4458 #define SPELLING_STRING 1
4459 #define SPELLING_MEMBER 2
4460 #define SPELLING_BOUNDS 3
4461
4462 static struct spelling *spelling;       /* Next stack element (unused).  */
4463 static struct spelling *spelling_base;  /* Spelling stack base.  */
4464 static int spelling_size;               /* Size of the spelling stack.  */
4465
4466 /* Macros to save and restore the spelling stack around push_... functions.
4467    Alternative to SAVE_SPELLING_STACK.  */
4468
4469 #define SPELLING_DEPTH() (spelling - spelling_base)
4470 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4471
4472 /* Save and restore the spelling stack around arbitrary C code.  */
4473
4474 #define SAVE_SPELLING_DEPTH(code)               \
4475 {                                               \
4476   int __depth = SPELLING_DEPTH ();              \
4477   code;                                         \
4478   RESTORE_SPELLING_DEPTH (__depth);             \
4479 }
4480
4481 /* Push an element on the spelling stack with type KIND and assign VALUE
4482    to MEMBER.  */
4483
4484 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4485 {                                                                       \
4486   int depth = SPELLING_DEPTH ();                                        \
4487                                                                         \
4488   if (depth >= spelling_size)                                           \
4489     {                                                                   \
4490       spelling_size += 10;                                              \
4491       if (spelling_base == 0)                                           \
4492         spelling_base                                                   \
4493           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4494       else                                                              \
4495         spelling_base                                                   \
4496           = (struct spelling *) xrealloc (spelling_base,                \
4497                                           spelling_size * sizeof (struct spelling));    \
4498       RESTORE_SPELLING_DEPTH (depth);                                   \
4499     }                                                                   \
4500                                                                         \
4501   spelling->kind = (KIND);                                              \
4502   spelling->MEMBER = (VALUE);                                           \
4503   spelling++;                                                           \
4504 }
4505
4506 /* Push STRING on the stack.  Printed literally.  */
4507
4508 static void
4509 push_string (string)
4510      const char *string;
4511 {
4512   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4513 }
4514
4515 /* Push a member name on the stack.  Printed as '.' STRING.  */
4516
4517 static void
4518 push_member_name (decl)
4519      tree decl;
4520
4521 {
4522   const char *const string
4523     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4524   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4525 }
4526
4527 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4528
4529 static void
4530 push_array_bounds (bounds)
4531      int bounds;
4532 {
4533   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4534 }
4535
4536 /* Compute the maximum size in bytes of the printed spelling.  */
4537
4538 static int
4539 spelling_length ()
4540 {
4541   int size = 0;
4542   struct spelling *p;
4543
4544   for (p = spelling_base; p < spelling; p++)
4545     {
4546       if (p->kind == SPELLING_BOUNDS)
4547         size += 25;
4548       else
4549         size += strlen (p->u.s) + 1;
4550     }
4551
4552   return size;
4553 }
4554
4555 /* Print the spelling to BUFFER and return it.  */
4556
4557 static char *
4558 print_spelling (buffer)
4559      char *buffer;
4560 {
4561   char *d = buffer;
4562   struct spelling *p;
4563
4564   for (p = spelling_base; p < spelling; p++)
4565     if (p->kind == SPELLING_BOUNDS)
4566       {
4567         sprintf (d, "[%d]", p->u.i);
4568         d += strlen (d);
4569       }
4570     else
4571       {
4572         const char *s;
4573         if (p->kind == SPELLING_MEMBER)
4574           *d++ = '.';
4575         for (s = p->u.s; (*d = *s++); d++)
4576           ;
4577       }
4578   *d++ = '\0';
4579   return buffer;
4580 }
4581
4582 /* Issue an error message for a bad initializer component.
4583    MSGID identifies the message.
4584    The component name is taken from the spelling stack.  */
4585
4586 void
4587 error_init (msgid)
4588      const char *msgid;
4589 {
4590   char *ofwhat;
4591
4592   error ("%s", msgid);
4593   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4594   if (*ofwhat)
4595     error ("(near initialization for `%s')", ofwhat);
4596 }
4597
4598 /* Issue a pedantic warning for a bad initializer component.
4599    MSGID identifies the message.
4600    The component name is taken from the spelling stack.  */
4601
4602 void
4603 pedwarn_init (msgid)
4604      const char *msgid;
4605 {
4606   char *ofwhat;
4607
4608   pedwarn ("%s", msgid);
4609   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4610   if (*ofwhat)
4611     pedwarn ("(near initialization for `%s')", ofwhat);
4612 }
4613
4614 /* Issue a warning for a bad initializer component.
4615    MSGID identifies the message.
4616    The component name is taken from the spelling stack.  */
4617
4618 static void
4619 warning_init (msgid)
4620      const char *msgid;
4621 {
4622   char *ofwhat;
4623
4624   warning ("%s", msgid);
4625   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4626   if (*ofwhat)
4627     warning ("(near initialization for `%s')", ofwhat);
4628 }
4629 \f
4630 /* Digest the parser output INIT as an initializer for type TYPE.
4631    Return a C expression of type TYPE to represent the initial value.
4632
4633    The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4634    if non-constant initializers or elements are seen.  CONSTRUCTOR_CONSTANT
4635    applies only to elements of constructors.  */
4636
4637 static tree
4638 digest_init (type, init, require_constant, constructor_constant)
4639      tree type, init;
4640      int require_constant, constructor_constant;
4641 {
4642   enum tree_code code = TREE_CODE (type);
4643   tree inside_init = init;
4644
4645   if (type == error_mark_node
4646       || init == error_mark_node
4647       || TREE_TYPE (init)  == error_mark_node)
4648     return error_mark_node;
4649
4650   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4651   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4652      whose value is 0 to count as a null pointer constant.  */
4653   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4654     inside_init = TREE_OPERAND (init, 0);
4655
4656   inside_init = fold (inside_init);
4657
4658   /* Initialization of an array of chars from a string constant
4659      optionally enclosed in braces.  */
4660
4661   if (code == ARRAY_TYPE)
4662     {
4663       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4664       if ((typ1 == char_type_node
4665            || typ1 == signed_char_type_node
4666            || typ1 == unsigned_char_type_node
4667            || typ1 == unsigned_wchar_type_node
4668            || typ1 == signed_wchar_type_node)
4669           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4670         {
4671           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4672                          TYPE_MAIN_VARIANT (type)))
4673             return inside_init;
4674
4675           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4676                != char_type_node)
4677               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4678             {
4679               error_init ("char-array initialized from wide string");
4680               return error_mark_node;
4681             }
4682           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4683                == char_type_node)
4684               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4685             {
4686               error_init ("int-array initialized from non-wide string");
4687               return error_mark_node;
4688             }
4689
4690           TREE_TYPE (inside_init) = type;
4691           if (TYPE_DOMAIN (type) != 0
4692               && TYPE_SIZE (type) != 0
4693               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4694               /* Subtract 1 (or sizeof (wchar_t))
4695                  because it's ok to ignore the terminating null char
4696                  that is counted in the length of the constant.  */
4697               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4698                                        TREE_STRING_LENGTH (inside_init)
4699                                        - ((TYPE_PRECISION (typ1)
4700                                            != TYPE_PRECISION (char_type_node))
4701                                           ? (TYPE_PRECISION (wchar_type_node)
4702                                              / BITS_PER_UNIT)
4703                                           : 1)))
4704             pedwarn_init ("initializer-string for array of chars is too long");
4705
4706           return inside_init;
4707         }
4708     }
4709
4710   /* Any type can be initialized
4711      from an expression of the same type, optionally with braces.  */
4712
4713   if (inside_init && TREE_TYPE (inside_init) != 0
4714       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4715                      TYPE_MAIN_VARIANT (type))
4716           || (code == ARRAY_TYPE
4717               && comptypes (TREE_TYPE (inside_init), type))
4718           || (code == POINTER_TYPE
4719               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4720                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4721               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4722                             TREE_TYPE (type)))))
4723     {
4724       if (code == POINTER_TYPE
4725           && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4726               || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4727         inside_init = default_conversion (inside_init);
4728       else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4729                && TREE_CODE (inside_init) != CONSTRUCTOR)
4730         {
4731           error_init ("array initialized from non-constant array expression");
4732           return error_mark_node;
4733         }
4734
4735       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4736         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4737
4738       /* Compound expressions can only occur here if -pedantic or
4739          -pedantic-errors is specified.  In the later case, we always want
4740          an error.  In the former case, we simply want a warning.  */
4741       if (require_constant && pedantic
4742           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4743         {
4744           inside_init
4745             = valid_compound_expr_initializer (inside_init,
4746                                                TREE_TYPE (inside_init));
4747           if (inside_init == error_mark_node)
4748             error_init ("initializer element is not constant");
4749           else
4750             pedwarn_init ("initializer element is not constant");
4751           if (flag_pedantic_errors)
4752             inside_init = error_mark_node;
4753         }
4754       else if (require_constant
4755                && (!TREE_CONSTANT (inside_init)
4756                    /* This test catches things like `7 / 0' which
4757                       result in an expression for which TREE_CONSTANT
4758                       is true, but which is not actually something
4759                       that is a legal constant.  We really should not
4760                       be using this function, because it is a part of
4761                       the back-end.  Instead, the expression should
4762                       already have been turned into ERROR_MARK_NODE.  */
4763                    || !initializer_constant_valid_p (inside_init,
4764                                                      TREE_TYPE (inside_init))))
4765         {
4766           error_init ("initializer element is not constant");
4767           inside_init = error_mark_node;
4768         }
4769
4770       return inside_init;
4771     }
4772
4773   /* Handle scalar types, including conversions.  */
4774
4775   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4776       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4777     {
4778       /* Note that convert_for_assignment calls default_conversion
4779          for arrays and functions.  We must not call it in the
4780          case where inside_init is a null pointer constant.  */
4781       inside_init
4782         = convert_for_assignment (type, init, _("initialization"),
4783                                   NULL_TREE, NULL_TREE, 0);
4784
4785       if (require_constant && ! TREE_CONSTANT (inside_init))
4786         {
4787           error_init ("initializer element is not constant");
4788           inside_init = error_mark_node;
4789         }
4790       else if (require_constant
4791                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4792         {
4793           error_init ("initializer element is not computable at load time");
4794           inside_init = error_mark_node;
4795         }
4796
4797       return inside_init;
4798     }
4799
4800   /* Come here only for records and arrays.  */
4801
4802   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4803     {
4804       error_init ("variable-sized object may not be initialized");
4805       return error_mark_node;
4806     }
4807
4808   /* Traditionally, you can write  struct foo x = 0;
4809      and it initializes the first element of x to 0.  */
4810   if (flag_traditional)
4811     {
4812       tree top = 0, prev = 0, otype = type;
4813       while (TREE_CODE (type) == RECORD_TYPE
4814              || TREE_CODE (type) == ARRAY_TYPE
4815              || TREE_CODE (type) == QUAL_UNION_TYPE
4816              || TREE_CODE (type) == UNION_TYPE)
4817         {
4818           tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4819           if (prev == 0)
4820             top = temp;
4821           else
4822             TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4823           prev = temp;
4824           if (TREE_CODE (type) == ARRAY_TYPE)
4825             type = TREE_TYPE (type);
4826           else if (TYPE_FIELDS (type))
4827             type = TREE_TYPE (TYPE_FIELDS (type));
4828           else
4829             {
4830               error_init ("invalid initializer");
4831               return error_mark_node;
4832             }
4833         }
4834
4835       if (otype != type)
4836         {
4837           TREE_OPERAND (prev, 1)
4838             = build_tree_list (NULL_TREE,
4839                                digest_init (type, init, require_constant,
4840                                             constructor_constant));
4841           return top;
4842         }
4843       else
4844         return error_mark_node;
4845     }
4846   error_init ("invalid initializer");
4847   return error_mark_node;
4848 }
4849 \f
4850 /* Handle initializers that use braces.  */
4851
4852 /* Type of object we are accumulating a constructor for.
4853    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4854 static tree constructor_type;
4855
4856 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4857    left to fill.  */
4858 static tree constructor_fields;
4859
4860 /* For an ARRAY_TYPE, this is the specified index
4861    at which to store the next element we get.  */
4862 static tree constructor_index;
4863
4864 /* For an ARRAY_TYPE, this is the maximum index.  */
4865 static tree constructor_max_index;
4866
4867 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4868 static tree constructor_unfilled_fields;
4869
4870 /* For an ARRAY_TYPE, this is the index of the first element
4871    not yet written out.  */
4872 static tree constructor_unfilled_index;
4873
4874 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4875    This is so we can generate gaps between fields, when appropriate.  */
4876 static tree constructor_bit_index;
4877
4878 /* If we are saving up the elements rather than allocating them,
4879    this is the list of elements so far (in reverse order,
4880    most recent first).  */
4881 static tree constructor_elements;
4882
4883 /* 1 if constructor should be incrementally stored into a constructor chain,
4884    0 if all the elements should be kept in AVL tree.  */
4885 static int constructor_incremental;
4886
4887 /* 1 if so far this constructor's elements are all compile-time constants.  */
4888 static int constructor_constant;
4889
4890 /* 1 if so far this constructor's elements are all valid address constants.  */
4891 static int constructor_simple;
4892
4893 /* 1 if this constructor is erroneous so far.  */
4894 static int constructor_erroneous;
4895
4896 /* 1 if have called defer_addressed_constants.  */
4897 static int constructor_subconstants_deferred;
4898
4899 /* Structure for managing pending initializer elements, organized as an
4900    AVL tree.  */
4901
4902 struct init_node
4903 {
4904   struct init_node *left, *right;
4905   struct init_node *parent;
4906   int balance;
4907   tree purpose;
4908   tree value;
4909 };
4910
4911 /* Tree of pending elements at this constructor level.
4912    These are elements encountered out of order
4913    which belong at places we haven't reached yet in actually
4914    writing the output.
4915    Will never hold tree nodes across GC runs.  */
4916 static struct init_node *constructor_pending_elts;
4917
4918 /* The SPELLING_DEPTH of this constructor.  */
4919 static int constructor_depth;
4920
4921 /* 0 if implicitly pushing constructor levels is allowed.  */
4922 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4923
4924 static int require_constant_value;
4925 static int require_constant_elements;
4926
4927 /* DECL node for which an initializer is being read.
4928    0 means we are reading a constructor expression
4929    such as (struct foo) {...}.  */
4930 static tree constructor_decl;
4931
4932 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4933 static const char *constructor_asmspec;
4934
4935 /* Nonzero if this is an initializer for a top-level decl.  */
4936 static int constructor_top_level;
4937
4938 /* Nesting depth of designator list.  */
4939 static int designator_depth;
4940
4941 /* Nonzero if there were diagnosed errors in this designator list.  */
4942 static int designator_errorneous;
4943
4944 \f
4945 /* This stack has a level for each implicit or explicit level of
4946    structuring in the initializer, including the outermost one.  It
4947    saves the values of most of the variables above.  */
4948
4949 struct constructor_range_stack;
4950
4951 struct constructor_stack
4952 {
4953   struct constructor_stack *next;
4954   tree type;
4955   tree fields;
4956   tree index;
4957   tree max_index;
4958   tree unfilled_index;
4959   tree unfilled_fields;
4960   tree bit_index;
4961   tree elements;
4962   struct init_node *pending_elts;
4963   int offset;
4964   int depth;
4965   /* If nonzero, this value should replace the entire
4966      constructor at this level.  */
4967   tree replacement_value;
4968   struct constructor_range_stack *range_stack;
4969   char constant;
4970   char simple;
4971   char implicit;
4972   char erroneous;
4973   char outer;
4974   char incremental;
4975 };
4976
4977 struct constructor_stack *constructor_stack;
4978
4979 /* This stack represents designators from some range designator up to
4980    the last designator in the list.  */
4981
4982 struct constructor_range_stack
4983 {
4984   struct constructor_range_stack *next, *prev;
4985   struct constructor_stack *stack;
4986   tree range_start;
4987   tree index;
4988   tree range_end;
4989   tree fields;
4990 };
4991
4992 struct constructor_range_stack *constructor_range_stack;
4993
4994 /* This stack records separate initializers that are nested.
4995    Nested initializers can't happen in ANSI C, but GNU C allows them
4996    in cases like { ... (struct foo) { ... } ... }.  */
4997
4998 struct initializer_stack
4999 {
5000   struct initializer_stack *next;
5001   tree decl;
5002   const char *asmspec;
5003   struct constructor_stack *constructor_stack;
5004   struct constructor_range_stack *constructor_range_stack;
5005   tree elements;
5006   struct spelling *spelling;
5007   struct spelling *spelling_base;
5008   int spelling_size;
5009   char top_level;
5010   char require_constant_value;
5011   char require_constant_elements;
5012   char deferred;
5013 };
5014
5015 struct initializer_stack *initializer_stack;
5016 \f
5017 /* Prepare to parse and output the initializer for variable DECL.  */
5018
5019 void
5020 start_init (decl, asmspec_tree, top_level)
5021      tree decl;
5022      tree asmspec_tree;
5023      int top_level;
5024 {
5025   const char *locus;
5026   struct initializer_stack *p
5027     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5028   const char *asmspec = 0;
5029
5030   if (asmspec_tree)
5031     asmspec = TREE_STRING_POINTER (asmspec_tree);
5032
5033   p->decl = constructor_decl;
5034   p->asmspec = constructor_asmspec;
5035   p->require_constant_value = require_constant_value;
5036   p->require_constant_elements = require_constant_elements;
5037   p->constructor_stack = constructor_stack;
5038   p->constructor_range_stack = constructor_range_stack;
5039   p->elements = constructor_elements;
5040   p->spelling = spelling;
5041   p->spelling_base = spelling_base;
5042   p->spelling_size = spelling_size;
5043   p->deferred = constructor_subconstants_deferred;
5044   p->top_level = constructor_top_level;
5045   p->next = initializer_stack;
5046   initializer_stack = p;
5047
5048   constructor_decl = decl;
5049   constructor_asmspec = asmspec;
5050   constructor_subconstants_deferred = 0;
5051   constructor_top_level = top_level;
5052
5053   if (decl != 0)
5054     {
5055       require_constant_value = TREE_STATIC (decl);
5056       require_constant_elements
5057         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5058            /* For a scalar, you can always use any value to initialize,
5059               even within braces.  */
5060            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5061                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5062                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5063                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5064       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5065     }
5066   else
5067     {
5068       require_constant_value = 0;
5069       require_constant_elements = 0;
5070       locus = "(anonymous)";
5071     }
5072
5073   constructor_stack = 0;
5074   constructor_range_stack = 0;
5075
5076   missing_braces_mentioned = 0;
5077
5078   spelling_base = 0;
5079   spelling_size = 0;
5080   RESTORE_SPELLING_DEPTH (0);
5081
5082   if (locus)
5083     push_string (locus);
5084 }
5085
5086 void
5087 finish_init ()
5088 {
5089   struct initializer_stack *p = initializer_stack;
5090
5091   /* Output subconstants (string constants, usually)
5092      that were referenced within this initializer and saved up.
5093      Must do this if and only if we called defer_addressed_constants.  */
5094   if (constructor_subconstants_deferred)
5095     output_deferred_addressed_constants ();
5096
5097   /* Free the whole constructor stack of this initializer.  */
5098   while (constructor_stack)
5099     {
5100       struct constructor_stack *q = constructor_stack;
5101       constructor_stack = q->next;
5102       free (q);
5103     }
5104
5105   if (constructor_range_stack)
5106     abort ();
5107
5108   /* Pop back to the data of the outer initializer (if any).  */
5109   constructor_decl = p->decl;
5110   constructor_asmspec = p->asmspec;
5111   require_constant_value = p->require_constant_value;
5112   require_constant_elements = p->require_constant_elements;
5113   constructor_stack = p->constructor_stack;
5114   constructor_range_stack = p->constructor_range_stack;
5115   constructor_elements = p->elements;
5116   spelling = p->spelling;
5117   spelling_base = p->spelling_base;
5118   spelling_size = p->spelling_size;
5119   constructor_subconstants_deferred = p->deferred;
5120   constructor_top_level = p->top_level;
5121   initializer_stack = p->next;
5122   free (p);
5123 }
5124 \f
5125 /* Call here when we see the initializer is surrounded by braces.
5126    This is instead of a call to push_init_level;
5127    it is matched by a call to pop_init_level.
5128
5129    TYPE is the type to initialize, for a constructor expression.
5130    For an initializer for a decl, TYPE is zero.  */
5131
5132 void
5133 really_start_incremental_init (type)
5134      tree type;
5135 {
5136   struct constructor_stack *p
5137     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5138
5139   if (type == 0)
5140     type = TREE_TYPE (constructor_decl);
5141
5142   p->type = constructor_type;
5143   p->fields = constructor_fields;
5144   p->index = constructor_index;
5145   p->max_index = constructor_max_index;
5146   p->unfilled_index = constructor_unfilled_index;
5147   p->unfilled_fields = constructor_unfilled_fields;
5148   p->bit_index = constructor_bit_index;
5149   p->elements = constructor_elements;
5150   p->constant = constructor_constant;
5151   p->simple = constructor_simple;
5152   p->erroneous = constructor_erroneous;
5153   p->pending_elts = constructor_pending_elts;
5154   p->depth = constructor_depth;
5155   p->replacement_value = 0;
5156   p->implicit = 0;
5157   p->range_stack = 0;
5158   p->outer = 0;
5159   p->incremental = constructor_incremental;
5160   p->next = 0;
5161   constructor_stack = p;
5162
5163   constructor_constant = 1;
5164   constructor_simple = 1;
5165   constructor_depth = SPELLING_DEPTH ();
5166   constructor_elements = 0;
5167   constructor_pending_elts = 0;
5168   constructor_type = type;
5169   constructor_incremental = 1;
5170   designator_depth = 0;
5171   designator_errorneous = 0;
5172
5173   if (TREE_CODE (constructor_type) == RECORD_TYPE
5174       || TREE_CODE (constructor_type) == UNION_TYPE)
5175     {
5176       constructor_fields = TYPE_FIELDS (constructor_type);
5177       /* Skip any nameless bit fields at the beginning.  */
5178       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5179              && DECL_NAME (constructor_fields) == 0)
5180         constructor_fields = TREE_CHAIN (constructor_fields);
5181
5182       constructor_unfilled_fields = constructor_fields;
5183       constructor_bit_index = bitsize_zero_node;
5184     }
5185   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5186     {
5187       if (TYPE_DOMAIN (constructor_type))
5188         {
5189           constructor_max_index
5190             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5191
5192           /* Detect non-empty initializations of zero-length arrays.  */
5193           if (constructor_max_index == NULL_TREE
5194               && TYPE_SIZE (constructor_type))
5195             constructor_max_index = build_int_2 (-1, -1);
5196
5197           constructor_index
5198             = convert (bitsizetype,
5199                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5200         }
5201       else
5202         constructor_index = bitsize_zero_node;
5203
5204       constructor_unfilled_index = constructor_index;
5205     }
5206   else
5207     {
5208       /* Handle the case of int x = {5}; */
5209       constructor_fields = constructor_type;
5210       constructor_unfilled_fields = constructor_type;
5211     }
5212 }
5213 \f
5214 /* Push down into a subobject, for initialization.
5215    If this is for an explicit set of braces, IMPLICIT is 0.
5216    If it is because the next element belongs at a lower level,
5217    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
5218
5219 void
5220 push_init_level (implicit)
5221      int implicit;
5222 {
5223   struct constructor_stack *p;
5224   tree value = NULL_TREE;
5225
5226   /* If we've exhausted any levels that didn't have braces,
5227      pop them now.  */
5228   while (constructor_stack->implicit)
5229     {
5230       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5231            || TREE_CODE (constructor_type) == UNION_TYPE)
5232           && constructor_fields == 0)
5233         process_init_element (pop_init_level (1));
5234       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5235                && tree_int_cst_lt (constructor_max_index, constructor_index))
5236         process_init_element (pop_init_level (1));
5237       else
5238         break;
5239     }
5240
5241   /* Unless this is an explicit brace, we need to preserve previous
5242      content if any.  */
5243   if (implicit)
5244     {
5245       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5246            || TREE_CODE (constructor_type) == UNION_TYPE)
5247           && constructor_fields)
5248         value = find_init_member (constructor_fields);
5249       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5250         value = find_init_member (constructor_index);
5251     }
5252
5253   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5254   p->type = constructor_type;
5255   p->fields = constructor_fields;
5256   p->index = constructor_index;
5257   p->max_index = constructor_max_index;
5258   p->unfilled_index = constructor_unfilled_index;
5259   p->unfilled_fields = constructor_unfilled_fields;
5260   p->bit_index = constructor_bit_index;
5261   p->elements = constructor_elements;
5262   p->constant = constructor_constant;
5263   p->simple = constructor_simple;
5264   p->erroneous = constructor_erroneous;
5265   p->pending_elts = constructor_pending_elts;
5266   p->depth = constructor_depth;
5267   p->replacement_value = 0;
5268   p->implicit = implicit;
5269   p->outer = 0;
5270   p->incremental = constructor_incremental;
5271   p->next = constructor_stack;
5272   p->range_stack = 0;
5273   constructor_stack = p;
5274
5275   constructor_constant = 1;
5276   constructor_simple = 1;
5277   constructor_depth = SPELLING_DEPTH ();
5278   constructor_elements = 0;
5279   constructor_incremental = 1;
5280   constructor_pending_elts = 0;
5281   if (!implicit)
5282     {
5283       p->range_stack = constructor_range_stack;
5284       constructor_range_stack = 0;
5285       designator_depth = 0;
5286       designator_errorneous = 0;
5287     }
5288
5289   /* Don't die if an entire brace-pair level is superfluous
5290      in the containing level.  */
5291   if (constructor_type == 0)
5292     ;
5293   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5294            || TREE_CODE (constructor_type) == UNION_TYPE)
5295     {
5296       /* Don't die if there are extra init elts at the end.  */
5297       if (constructor_fields == 0)
5298         constructor_type = 0;
5299       else
5300         {
5301           constructor_type = TREE_TYPE (constructor_fields);
5302           push_member_name (constructor_fields);
5303           constructor_depth++;
5304         }
5305     }
5306   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5307     {
5308       constructor_type = TREE_TYPE (constructor_type);
5309       push_array_bounds (tree_low_cst (constructor_index, 0));
5310       constructor_depth++;
5311     }
5312
5313   if (constructor_type == 0)
5314     {
5315       error_init ("extra brace group at end of initializer");
5316       constructor_fields = 0;
5317       constructor_unfilled_fields = 0;
5318       return;
5319     }
5320
5321   if (value && TREE_CODE (value) == CONSTRUCTOR)
5322     {
5323       constructor_constant = TREE_CONSTANT (value);
5324       constructor_simple = TREE_STATIC (value);
5325       constructor_elements = TREE_OPERAND (value, 1);
5326       if (constructor_elements
5327           && (TREE_CODE (constructor_type) == RECORD_TYPE
5328               || TREE_CODE (constructor_type) == ARRAY_TYPE))
5329         set_nonincremental_init ();
5330     }
5331
5332   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5333     {
5334       missing_braces_mentioned = 1;
5335       warning_init ("missing braces around initializer");
5336     }
5337
5338   if (TREE_CODE (constructor_type) == RECORD_TYPE
5339            || TREE_CODE (constructor_type) == UNION_TYPE)
5340     {
5341       constructor_fields = TYPE_FIELDS (constructor_type);
5342       /* Skip any nameless bit fields at the beginning.  */
5343       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5344              && DECL_NAME (constructor_fields) == 0)
5345         constructor_fields = TREE_CHAIN (constructor_fields);
5346
5347       constructor_unfilled_fields = constructor_fields;
5348       constructor_bit_index = bitsize_zero_node;
5349     }
5350   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5351     {
5352       if (TYPE_DOMAIN (constructor_type))
5353         {
5354           constructor_max_index
5355             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5356
5357           /* Detect non-empty initializations of zero-length arrays.  */
5358           if (constructor_max_index == NULL_TREE
5359               && TYPE_SIZE (constructor_type))
5360             constructor_max_index = build_int_2 (-1, -1);
5361
5362           constructor_index
5363             = convert (bitsizetype,
5364                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5365         }
5366       else
5367         constructor_index = bitsize_zero_node;
5368
5369       constructor_unfilled_index = constructor_index;
5370       if (value && TREE_CODE (value) == STRING_CST)
5371         {
5372           /* We need to split the char/wchar array into individual
5373              characters, so that we don't have to special case it
5374              everywhere.  */
5375           set_nonincremental_init_from_string (value);
5376         }
5377     }
5378   else
5379     {
5380       warning_init ("braces around scalar initializer");
5381       constructor_fields = constructor_type;
5382       constructor_unfilled_fields = constructor_type;
5383     }
5384 }
5385
5386 /* At the end of an implicit or explicit brace level,
5387    finish up that level of constructor.
5388    If we were outputting the elements as they are read, return 0
5389    from inner levels (process_init_element ignores that),
5390    but return error_mark_node from the outermost level
5391    (that's what we want to put in DECL_INITIAL).
5392    Otherwise, return a CONSTRUCTOR expression.  */
5393
5394 tree
5395 pop_init_level (implicit)
5396      int implicit;
5397 {
5398   struct constructor_stack *p;
5399   HOST_WIDE_INT size = 0;
5400   tree constructor = 0;
5401
5402   if (implicit == 0)
5403     {
5404       /* When we come to an explicit close brace,
5405          pop any inner levels that didn't have explicit braces.  */
5406       while (constructor_stack->implicit)
5407         process_init_element (pop_init_level (1));
5408
5409       if (constructor_range_stack)
5410         abort ();
5411     }
5412
5413   p = constructor_stack;
5414
5415   if (constructor_type != 0)
5416     size = int_size_in_bytes (constructor_type);
5417
5418   /* Error for initializing a flexible array member, or a zero-length
5419      array member in an inappropriate context.  */
5420   if (constructor_type && constructor_fields
5421       && TREE_CODE (constructor_type) == ARRAY_TYPE
5422       && TYPE_DOMAIN (constructor_type)
5423       && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5424     {
5425       /* Silently discard empty initializations.  The parser will
5426          already have pedwarned for empty brackets.  */
5427       if (integer_zerop (constructor_unfilled_index))
5428         constructor_type = NULL_TREE;
5429       else if (! TYPE_SIZE (constructor_type))
5430         {
5431           if (constructor_depth > 2)
5432             error_init ("initialization of flexible array member in a nested context");
5433           else if (pedantic)
5434             pedwarn_init ("initialization of a flexible array member");
5435
5436           /* We have already issued an error message for the existance
5437              of a flexible array member not at the end of the structure.
5438              Discard the initializer so that we do not abort later.  */
5439           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5440             constructor_type = NULL_TREE;
5441         }
5442       else
5443         /* Zero-length arrays are no longer special, so we should no longer
5444            get here.  */
5445         abort();
5446     }
5447
5448   /* Warn when some struct elements are implicitly initialized to zero.  */
5449   if (extra_warnings
5450       && constructor_type
5451       && TREE_CODE (constructor_type) == RECORD_TYPE
5452       && constructor_unfilled_fields)
5453     {
5454         /* Do not warn for flexible array members or zero-length arrays.  */
5455         while (constructor_unfilled_fields
5456                && (! DECL_SIZE (constructor_unfilled_fields)
5457                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5458           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5459
5460         if (constructor_unfilled_fields)
5461           {
5462             push_member_name (constructor_unfilled_fields);
5463             warning_init ("missing initializer");
5464             RESTORE_SPELLING_DEPTH (constructor_depth);
5465           }
5466     }
5467
5468   /* Now output all pending elements.  */
5469   constructor_incremental = 1;
5470   output_pending_init_elements (1);
5471
5472   /* Pad out the end of the structure.  */
5473   if (p->replacement_value)
5474     /* If this closes a superfluous brace pair,
5475        just pass out the element between them.  */
5476     constructor = p->replacement_value;
5477   else if (constructor_type == 0)
5478     ;
5479   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5480            && TREE_CODE (constructor_type) != UNION_TYPE
5481            && TREE_CODE (constructor_type) != ARRAY_TYPE)
5482     {
5483       /* A nonincremental scalar initializer--just return
5484          the element, after verifying there is just one.  */
5485       if (constructor_elements == 0)
5486         {
5487           if (!constructor_erroneous)
5488             error_init ("empty scalar initializer");
5489           constructor = error_mark_node;
5490         }
5491       else if (TREE_CHAIN (constructor_elements) != 0)
5492         {
5493           error_init ("extra elements in scalar initializer");
5494           constructor = TREE_VALUE (constructor_elements);
5495         }
5496       else
5497         constructor = TREE_VALUE (constructor_elements);
5498     }
5499   else
5500     {
5501       if (constructor_erroneous)
5502         constructor = error_mark_node;
5503       else
5504         {
5505           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5506                                nreverse (constructor_elements));
5507           if (constructor_constant)
5508             TREE_CONSTANT (constructor) = 1;
5509           if (constructor_constant && constructor_simple)
5510             TREE_STATIC (constructor) = 1;
5511         }
5512     }
5513
5514   constructor_type = p->type;
5515   constructor_fields = p->fields;
5516   constructor_index = p->index;
5517   constructor_max_index = p->max_index;
5518   constructor_unfilled_index = p->unfilled_index;
5519   constructor_unfilled_fields = p->unfilled_fields;
5520   constructor_bit_index = p->bit_index;
5521   constructor_elements = p->elements;
5522   constructor_constant = p->constant;
5523   constructor_simple = p->simple;
5524   constructor_erroneous = p->erroneous;
5525   constructor_incremental = p->incremental;
5526   constructor_pending_elts = p->pending_elts;
5527   constructor_depth = p->depth;
5528   if (!p->implicit)
5529     constructor_range_stack = p->range_stack;
5530   RESTORE_SPELLING_DEPTH (constructor_depth);
5531
5532   constructor_stack = p->next;
5533   free (p);
5534
5535   if (constructor == 0)
5536     {
5537       if (constructor_stack == 0)
5538         return error_mark_node;
5539       return NULL_TREE;
5540     }
5541   return constructor;
5542 }
5543
5544 /* Common handling for both array range and field name designators.
5545    ARRAY argument is non-zero for array ranges.  Returns zero for success.  */
5546
5547 static int
5548 set_designator (array)
5549      int array;
5550 {
5551   tree subtype;
5552   enum tree_code subcode;
5553
5554   /* Don't die if an entire brace-pair level is superfluous
5555      in the containing level.  */
5556   if (constructor_type == 0)
5557     return 1;
5558
5559   /* If there were errors in this designator list already, bail out silently.  */
5560   if (designator_errorneous)
5561     return 1;
5562
5563   if (!designator_depth)
5564     {
5565       if (constructor_range_stack)
5566         abort ();
5567
5568       /* Designator list starts at the level of closest explicit
5569          braces.  */
5570       while (constructor_stack->implicit)
5571         process_init_element (pop_init_level (1));
5572       return 0;
5573     }
5574
5575   if (constructor_no_implicit)
5576     {
5577       error_init ("initialization designators may not nest");
5578       return 1;
5579     }
5580
5581   if (TREE_CODE (constructor_type) == RECORD_TYPE
5582       || TREE_CODE (constructor_type) == UNION_TYPE)
5583     {
5584       subtype = TREE_TYPE (constructor_fields);
5585       if (subtype != error_mark_node)
5586         subtype = TYPE_MAIN_VARIANT (subtype);
5587     }
5588   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5589     {
5590       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5591     }
5592   else
5593     abort ();
5594
5595   subcode = TREE_CODE (subtype);
5596   if (array && subcode != ARRAY_TYPE)
5597     {
5598       error_init ("array index in non-array initializer");
5599       return 1;
5600     }
5601   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5602     {
5603       error_init ("field name not in record or union initializer");
5604       return 1;
5605     }
5606
5607   push_init_level (2);
5608   return 0;
5609 }
5610
5611 /* If there are range designators in designator list, push a new designator
5612    to constructor_range_stack.  RANGE_END is end of such stack range or
5613    NULL_TREE if there is no range designator at this level.  */
5614
5615 static void
5616 push_range_stack (range_end)
5617      tree range_end;
5618 {
5619   struct constructor_range_stack *p;
5620
5621   p = (struct constructor_range_stack *)
5622       ggc_alloc (sizeof (struct constructor_range_stack));
5623   p->prev = constructor_range_stack;
5624   p->next = 0;
5625   p->fields = constructor_fields;
5626   p->range_start = constructor_index;
5627   p->index = constructor_index;
5628   p->stack = constructor_stack;
5629   p->range_end = range_end;
5630   if (constructor_range_stack)
5631     constructor_range_stack->next = p;
5632   constructor_range_stack = p;
5633 }
5634
5635 /* Within an array initializer, specify the next index to be initialized.
5636    FIRST is that index.  If LAST is nonzero, then initialize a range
5637    of indices, running from FIRST through LAST.  */
5638
5639 void
5640 set_init_index (first, last)
5641      tree first, last;
5642 {
5643   if (set_designator (1))
5644     return;
5645
5646   designator_errorneous = 1;
5647
5648   while ((TREE_CODE (first) == NOP_EXPR
5649           || TREE_CODE (first) == CONVERT_EXPR
5650           || TREE_CODE (first) == NON_LVALUE_EXPR)
5651          && (TYPE_MODE (TREE_TYPE (first))
5652              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5653     first = TREE_OPERAND (first, 0);
5654
5655   if (last)
5656     while ((TREE_CODE (last) == NOP_EXPR
5657             || TREE_CODE (last) == CONVERT_EXPR
5658             || TREE_CODE (last) == NON_LVALUE_EXPR)
5659            && (TYPE_MODE (TREE_TYPE (last))
5660                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5661       last = TREE_OPERAND (last, 0);
5662
5663   if (TREE_CODE (first) != INTEGER_CST)
5664     error_init ("nonconstant array index in initializer");
5665   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5666     error_init ("nonconstant array index in initializer");
5667   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5668     error_init ("array index in non-array initializer");
5669   else if (constructor_max_index
5670            && tree_int_cst_lt (constructor_max_index, first))
5671     error_init ("array index in initializer exceeds array bounds");
5672   else
5673     {
5674       constructor_index = convert (bitsizetype, first);
5675
5676       if (last)
5677         {
5678           if (tree_int_cst_equal (first, last))
5679             last = 0;
5680           else if (tree_int_cst_lt (last, first))
5681             {
5682               error_init ("empty index range in initializer");
5683               last = 0;
5684             }
5685           else
5686             {
5687               last = convert (bitsizetype, last);
5688               if (constructor_max_index != 0
5689                   && tree_int_cst_lt (constructor_max_index, last))
5690                 {
5691                   error_init ("array index range in initializer exceeds array bounds");
5692                   last = 0;
5693                 }
5694             }
5695         }
5696
5697       designator_depth++;
5698       designator_errorneous = 0;
5699       if (constructor_range_stack || last)
5700         push_range_stack (last);
5701     }
5702 }
5703
5704 /* Within a struct initializer, specify the next field to be initialized.  */
5705
5706 void
5707 set_init_label (fieldname)
5708      tree fieldname;
5709 {
5710   tree tail;
5711
5712   if (set_designator (0))
5713     return;
5714
5715   designator_errorneous = 1;
5716
5717   if (TREE_CODE (constructor_type) != RECORD_TYPE
5718       && TREE_CODE (constructor_type) != UNION_TYPE)
5719     {
5720       error_init ("field name not in record or union initializer");
5721       return;
5722     }
5723
5724   for (tail = TYPE_FIELDS (constructor_type); tail;
5725        tail = TREE_CHAIN (tail))
5726     {
5727       if (DECL_NAME (tail) == fieldname)
5728         break;
5729     }
5730
5731   if (tail == 0)
5732     error ("unknown field `%s' specified in initializer",
5733            IDENTIFIER_POINTER (fieldname));
5734   else
5735     {
5736       constructor_fields = tail;
5737       designator_depth++;
5738       designator_errorneous = 0;
5739       if (constructor_range_stack)
5740         push_range_stack (NULL_TREE);
5741     }
5742 }
5743 \f
5744 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5745    indentifies the initializer, either array index or field in a structure.
5746    VALUE is the value of that index or field.  */
5747
5748 static void
5749 add_pending_init (purpose, value)
5750      tree purpose, value;
5751 {
5752   struct init_node *p, **q, *r;
5753
5754   q = &constructor_pending_elts;
5755   p = 0;
5756
5757   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5758     {
5759       while (*q != 0)
5760         {
5761           p = *q;
5762           if (tree_int_cst_lt (purpose, p->purpose))
5763             q = &p->left;
5764           else if (tree_int_cst_lt (p->purpose, purpose))
5765             q = &p->right;
5766           else
5767             {
5768               if (TREE_SIDE_EFFECTS (p->value))
5769                 warning_init ("initialized field with side-effects overwritten");
5770               p->value = value;
5771               return;
5772             }
5773         }
5774     }
5775   else
5776     {
5777       tree bitpos;
5778
5779       bitpos = bit_position (purpose);
5780       while (*q != NULL)
5781         {
5782           p = *q;
5783           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5784             q = &p->left;
5785           else if (p->purpose != purpose)
5786             q = &p->right;
5787           else
5788             {
5789               if (TREE_SIDE_EFFECTS (p->value))
5790                 warning_init ("initialized field with side-effects overwritten");
5791               p->value = value;
5792               return;
5793             }
5794         }
5795     }
5796
5797   r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
5798   r->purpose = purpose;
5799   r->value = value;
5800
5801   *q = r;
5802   r->parent = p;
5803   r->left = 0;
5804   r->right = 0;
5805   r->balance = 0;
5806
5807   while (p)
5808     {
5809       struct init_node *s;
5810
5811       if (r == p->left)
5812         {
5813           if (p->balance == 0)
5814             p->balance = -1;
5815           else if (p->balance < 0)
5816             {
5817               if (r->balance < 0)
5818                 {
5819                   /* L rotation.  */
5820                   p->left = r->right;
5821                   if (p->left)
5822                     p->left->parent = p;
5823                   r->right = p;
5824
5825                   p->balance = 0;
5826                   r->balance = 0;
5827
5828                   s = p->parent;
5829                   p->parent = r;
5830                   r->parent = s;
5831                   if (s)
5832                     {
5833                       if (s->left == p)
5834                         s->left = r;
5835                       else
5836                         s->right = r;
5837                     }
5838                   else
5839                     constructor_pending_elts = r;
5840                 }
5841               else
5842                 {
5843                   /* LR rotation.  */
5844                   struct init_node *t = r->right;
5845
5846                   r->right = t->left;
5847                   if (r->right)
5848                     r->right->parent = r;
5849                   t->left = r;
5850
5851                   p->left = t->right;
5852                   if (p->left)
5853                     p->left->parent = p;
5854                   t->right = p;
5855
5856                   p->balance = t->balance < 0;
5857                   r->balance = -(t->balance > 0);
5858                   t->balance = 0;
5859
5860                   s = p->parent;
5861                   p->parent = t;
5862                   r->parent = t;
5863                   t->parent = s;
5864                   if (s)
5865                     {
5866                       if (s->left == p)
5867                         s->left = t;
5868                       else
5869                         s->right = t;
5870                     }
5871                   else
5872                     constructor_pending_elts = t;
5873                 }
5874               break;
5875             }
5876           else
5877             {
5878               /* p->balance == +1; growth of left side balances the node.  */
5879               p->balance = 0;
5880               break;
5881             }
5882         }
5883       else /* r == p->right */
5884         {
5885           if (p->balance == 0)
5886             /* Growth propagation from right side.  */
5887             p->balance++;
5888           else if (p->balance > 0)
5889             {
5890               if (r->balance > 0)
5891                 {
5892                   /* R rotation.  */
5893                   p->right = r->left;
5894                   if (p->right)
5895                     p->right->parent = p;
5896                   r->left = p;
5897
5898                   p->balance = 0;
5899                   r->balance = 0;
5900
5901                   s = p->parent;
5902                   p->parent = r;
5903                   r->parent = s;
5904                   if (s)
5905                     {
5906                       if (s->left == p)
5907                         s->left = r;
5908                       else
5909                         s->right = r;
5910                     }
5911                   else
5912                     constructor_pending_elts = r;
5913                 }
5914               else /* r->balance == -1 */
5915                 {
5916                   /* RL rotation */
5917                   struct init_node *t = r->left;
5918
5919                   r->left = t->right;
5920                   if (r->left)
5921                     r->left->parent = r;
5922                   t->right = r;
5923
5924                   p->right = t->left;
5925                   if (p->right)
5926                     p->right->parent = p;
5927                   t->left = p;
5928
5929                   r->balance = (t->balance < 0);
5930                   p->balance = -(t->balance > 0);
5931                   t->balance = 0;
5932
5933                   s = p->parent;
5934                   p->parent = t;
5935                   r->parent = t;
5936                   t->parent = s;
5937                   if (s)
5938                     {
5939                       if (s->left == p)
5940                         s->left = t;
5941                       else
5942                         s->right = t;
5943                     }
5944                   else
5945                     constructor_pending_elts = t;
5946                 }
5947               break;
5948             }
5949           else
5950             {
5951               /* p->balance == -1; growth of right side balances the node.  */
5952               p->balance = 0;
5953               break;
5954             }
5955         }
5956
5957       r = p;
5958       p = p->parent;
5959     }
5960 }
5961
5962 /* Build AVL tree from a sorted chain.  */
5963
5964 static void
5965 set_nonincremental_init ()
5966 {
5967   tree chain;
5968
5969   if (TREE_CODE (constructor_type) != RECORD_TYPE
5970       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5971     return;
5972
5973   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5974     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5975   constructor_elements = 0;
5976   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5977     {
5978       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5979       /* Skip any nameless bit fields at the beginning.  */
5980       while (constructor_unfilled_fields != 0
5981              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5982              && DECL_NAME (constructor_unfilled_fields) == 0)
5983         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5984
5985     }
5986   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5987     {
5988       if (TYPE_DOMAIN (constructor_type))
5989         constructor_unfilled_index
5990             = convert (bitsizetype,
5991                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5992       else
5993         constructor_unfilled_index = bitsize_zero_node;
5994     }
5995   constructor_incremental = 0;
5996 }
5997
5998 /* Build AVL tree from a string constant.  */
5999
6000 static void
6001 set_nonincremental_init_from_string (str)
6002      tree str;
6003 {
6004   tree value, purpose, type;
6005   HOST_WIDE_INT val[2];
6006   const char *p, *end;
6007   int byte, wchar_bytes, charwidth, bitpos;
6008
6009   if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6010     abort ();
6011
6012   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6013       == TYPE_PRECISION (char_type_node))
6014     wchar_bytes = 1;
6015   else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
6016            == TYPE_PRECISION (wchar_type_node))
6017     wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
6018   else
6019     abort ();
6020
6021   charwidth = TYPE_PRECISION (char_type_node);
6022   type = TREE_TYPE (constructor_type);
6023   p = TREE_STRING_POINTER (str);
6024   end = p + TREE_STRING_LENGTH (str);
6025
6026   for (purpose = bitsize_zero_node;
6027        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6028        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6029     {
6030       if (wchar_bytes == 1)
6031         {
6032           val[1] = (unsigned char) *p++;
6033           val[0] = 0;
6034         }
6035       else
6036         {
6037           val[0] = 0;
6038           val[1] = 0;
6039           for (byte = 0; byte < wchar_bytes; byte++)
6040             {
6041               if (BYTES_BIG_ENDIAN)
6042                 bitpos = (wchar_bytes - byte - 1) * charwidth;
6043               else
6044                 bitpos = byte * charwidth;
6045               val[bitpos < HOST_BITS_PER_WIDE_INT]
6046                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6047                    << (bitpos % HOST_BITS_PER_WIDE_INT);
6048             }
6049         }
6050
6051       if (!TREE_UNSIGNED (type))
6052         {
6053           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6054           if (bitpos < HOST_BITS_PER_WIDE_INT)
6055             {
6056               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6057                 {
6058                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6059                   val[0] = -1;
6060                 }
6061             }
6062           else if (bitpos == HOST_BITS_PER_WIDE_INT)
6063             {
6064               if (val[1] < 0)
6065                 val[0] = -1;
6066             }
6067           else if (val[0] & (((HOST_WIDE_INT) 1)
6068                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6069             val[0] |= ((HOST_WIDE_INT) -1)
6070                       << (bitpos - HOST_BITS_PER_WIDE_INT);
6071         }
6072
6073       value = build_int_2 (val[1], val[0]);
6074       TREE_TYPE (value) = type;
6075       add_pending_init (purpose, value);
6076     }
6077
6078   constructor_incremental = 0;
6079 }
6080
6081 /* Return value of FIELD in pending initializer or zero if the field was
6082    not initialized yet.  */
6083
6084 static tree
6085 find_init_member (field)
6086      tree field;
6087 {
6088   struct init_node *p;
6089
6090   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6091     {
6092       if (constructor_incremental
6093           && tree_int_cst_lt (field, constructor_unfilled_index))
6094         set_nonincremental_init ();
6095
6096       p = constructor_pending_elts;
6097       while (p)
6098         {
6099           if (tree_int_cst_lt (field, p->purpose))
6100             p = p->left;
6101           else if (tree_int_cst_lt (p->purpose, field))
6102             p = p->right;
6103           else
6104             return p->value;
6105         }
6106     }
6107   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6108     {
6109       tree bitpos = bit_position (field);
6110
6111       if (constructor_incremental
6112           && (!constructor_unfilled_fields
6113               || tree_int_cst_lt (bitpos,
6114                                   bit_position (constructor_unfilled_fields))))
6115         set_nonincremental_init ();
6116
6117       p = constructor_pending_elts;
6118       while (p)
6119         {
6120           if (field == p->purpose)
6121             return p->value;
6122           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6123             p = p->left;
6124           else
6125             p = p->right;
6126         }
6127     }
6128   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6129     {
6130       if (constructor_elements
6131           && TREE_PURPOSE (constructor_elements) == field)
6132         return TREE_VALUE (constructor_elements);
6133     }
6134   return 0;
6135 }
6136
6137 /* "Output" the next constructor element.
6138    At top level, really output it to assembler code now.
6139    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6140    TYPE is the data type that the containing data type wants here.
6141    FIELD is the field (a FIELD_DECL) or the index that this element fills.
6142
6143    PENDING if non-nil means output pending elements that belong
6144    right after this element.  (PENDING is normally 1;
6145    it is 0 while outputting pending elements, to avoid recursion.)  */
6146
6147 static void
6148 output_init_element (value, type, field, pending)
6149      tree value, type, field;
6150      int pending;
6151 {
6152   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6153       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6154           && !(TREE_CODE (value) == STRING_CST
6155                && TREE_CODE (type) == ARRAY_TYPE
6156                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6157           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6158                          TYPE_MAIN_VARIANT (type))))
6159     value = default_conversion (value);
6160
6161   if (value == error_mark_node)
6162     constructor_erroneous = 1;
6163   else if (!TREE_CONSTANT (value))
6164     constructor_constant = 0;
6165   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6166            || ((TREE_CODE (constructor_type) == RECORD_TYPE
6167                 || TREE_CODE (constructor_type) == UNION_TYPE)
6168                && DECL_C_BIT_FIELD (field)
6169                && TREE_CODE (value) != INTEGER_CST))
6170     constructor_simple = 0;
6171
6172   if (require_constant_value && ! TREE_CONSTANT (value))
6173     {
6174       error_init ("initializer element is not constant");
6175       value = error_mark_node;
6176     }
6177   else if (require_constant_elements
6178            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6179     pedwarn ("initializer element is not computable at load time");
6180
6181   /* If this field is empty (and not at the end of structure),
6182      don't do anything other than checking the initializer.  */
6183   if (field
6184       && (TREE_TYPE (field) == error_mark_node
6185           || (COMPLETE_TYPE_P (TREE_TYPE (field))
6186               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6187               && (TREE_CODE (constructor_type) == ARRAY_TYPE
6188                   || TREE_CHAIN (field)))))
6189     return;
6190
6191   if (value == error_mark_node)
6192     {
6193       constructor_erroneous = 1;
6194       return;
6195     }
6196
6197   /* If this element doesn't come next in sequence,
6198      put it on constructor_pending_elts.  */
6199   if (TREE_CODE (constructor_type) == ARRAY_TYPE
6200       && (!constructor_incremental
6201           || !tree_int_cst_equal (field, constructor_unfilled_index)))
6202     {
6203       if (constructor_incremental
6204           && tree_int_cst_lt (field, constructor_unfilled_index))
6205         set_nonincremental_init ();
6206
6207       add_pending_init (field,
6208                         digest_init (type, value, require_constant_value,
6209                                      require_constant_elements));
6210       return;
6211     }
6212   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6213            && (!constructor_incremental
6214                || field != constructor_unfilled_fields))
6215     {
6216       /* We do this for records but not for unions.  In a union,
6217          no matter which field is specified, it can be initialized
6218          right away since it starts at the beginning of the union.  */
6219       if (constructor_incremental)
6220         {
6221           if (!constructor_unfilled_fields)
6222             set_nonincremental_init ();
6223           else
6224             {
6225               tree bitpos, unfillpos;
6226
6227               bitpos = bit_position (field);
6228               unfillpos = bit_position (constructor_unfilled_fields);
6229
6230               if (tree_int_cst_lt (bitpos, unfillpos))
6231                 set_nonincremental_init ();
6232             }
6233         }
6234
6235       add_pending_init (field,
6236                         digest_init (type, value, require_constant_value,
6237                                      require_constant_elements));
6238       return;
6239     }
6240   else if (TREE_CODE (constructor_type) == UNION_TYPE
6241            && constructor_elements)
6242     {
6243       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
6244         warning_init ("initialized field with side-effects overwritten");
6245
6246       /* We can have just one union field set.  */
6247       constructor_elements = 0;
6248     }
6249
6250   /* Otherwise, output this element either to
6251      constructor_elements or to the assembler file.  */
6252
6253   if (field && TREE_CODE (field) == INTEGER_CST)
6254     field = copy_node (field);
6255   constructor_elements
6256     = tree_cons (field, digest_init (type, value,
6257                                      require_constant_value,
6258                                      require_constant_elements),
6259                  constructor_elements);
6260
6261   /* Advance the variable that indicates sequential elements output.  */
6262   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6263     constructor_unfilled_index
6264       = size_binop (PLUS_EXPR, constructor_unfilled_index,
6265                     bitsize_one_node);
6266   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6267     {
6268       constructor_unfilled_fields
6269         = TREE_CHAIN (constructor_unfilled_fields);
6270
6271       /* Skip any nameless bit fields.  */
6272       while (constructor_unfilled_fields != 0
6273              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6274              && DECL_NAME (constructor_unfilled_fields) == 0)
6275         constructor_unfilled_fields =
6276           TREE_CHAIN (constructor_unfilled_fields);
6277     }
6278   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6279     constructor_unfilled_fields = 0;
6280
6281   /* Now output any pending elements which have become next.  */
6282   if (pending)
6283     output_pending_init_elements (0);
6284 }
6285
6286 /* Output any pending elements which have become next.
6287    As we output elements, constructor_unfilled_{fields,index}
6288    advances, which may cause other elements to become next;
6289    if so, they too are output.
6290
6291    If ALL is 0, we return when there are
6292    no more pending elements to output now.
6293
6294    If ALL is 1, we output space as necessary so that
6295    we can output all the pending elements.  */
6296
6297 static void
6298 output_pending_init_elements (all)
6299      int all;
6300 {
6301   struct init_node *elt = constructor_pending_elts;
6302   tree next;
6303
6304  retry:
6305
6306   /* Look thru the whole pending tree.
6307      If we find an element that should be output now,
6308      output it.  Otherwise, set NEXT to the element
6309      that comes first among those still pending.  */
6310
6311   next = 0;
6312   while (elt)
6313     {
6314       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6315         {
6316           if (tree_int_cst_equal (elt->purpose,
6317                                   constructor_unfilled_index))
6318             output_init_element (elt->value,
6319                                  TREE_TYPE (constructor_type),
6320                                  constructor_unfilled_index, 0);
6321           else if (tree_int_cst_lt (constructor_unfilled_index,
6322                                     elt->purpose))
6323             {
6324               /* Advance to the next smaller node.  */
6325               if (elt->left)
6326                 elt = elt->left;
6327               else
6328                 {
6329                   /* We have reached the smallest node bigger than the
6330                      current unfilled index.  Fill the space first.  */
6331                   next = elt->purpose;
6332                   break;
6333                 }
6334             }
6335           else
6336             {
6337               /* Advance to the next bigger node.  */
6338               if (elt->right)
6339                 elt = elt->right;
6340               else
6341                 {
6342                   /* We have reached the biggest node in a subtree.  Find
6343                      the parent of it, which is the next bigger node.  */
6344                   while (elt->parent && elt->parent->right == elt)
6345                     elt = elt->parent;
6346                   elt = elt->parent;
6347                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6348                                               elt->purpose))
6349                     {
6350                       next = elt->purpose;
6351                       break;
6352                     }
6353                 }
6354             }
6355         }
6356       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6357                || TREE_CODE (constructor_type) == UNION_TYPE)
6358         {
6359           tree ctor_unfilled_bitpos, elt_bitpos;
6360
6361           /* If the current record is complete we are done.  */
6362           if (constructor_unfilled_fields == 0)
6363             break;
6364
6365           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6366           elt_bitpos = bit_position (elt->purpose);
6367           /* We can't compare fields here because there might be empty
6368              fields in between.  */
6369           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6370             {
6371               constructor_unfilled_fields = elt->purpose;
6372               output_init_element (elt->value, TREE_TYPE (elt->purpose),
6373                                    elt->purpose, 0);
6374             }
6375           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6376             {
6377               /* Advance to the next smaller node.  */
6378               if (elt->left)
6379                 elt = elt->left;
6380               else
6381                 {
6382                   /* We have reached the smallest node bigger than the
6383                      current unfilled field.  Fill the space first.  */
6384                   next = elt->purpose;
6385                   break;
6386                 }
6387             }
6388           else
6389             {
6390               /* Advance to the next bigger node.  */
6391               if (elt->right)
6392                 elt = elt->right;
6393               else
6394                 {
6395                   /* We have reached the biggest node in a subtree.  Find
6396                      the parent of it, which is the next bigger node.  */
6397                   while (elt->parent && elt->parent->right == elt)
6398                     elt = elt->parent;
6399                   elt = elt->parent;
6400                   if (elt
6401                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
6402                                            bit_position (elt->purpose))))
6403                     {
6404                       next = elt->purpose;
6405                       break;
6406                     }
6407                 }
6408             }
6409         }
6410     }
6411
6412   /* Ordinarily return, but not if we want to output all
6413      and there are elements left.  */
6414   if (! (all && next != 0))
6415     return;
6416
6417   /* If it's not incremental, just skip over the gap, so that after
6418      jumping to retry we will output the next successive element.  */
6419   if (TREE_CODE (constructor_type) == RECORD_TYPE
6420       || TREE_CODE (constructor_type) == UNION_TYPE)
6421     constructor_unfilled_fields = next;
6422   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6423     constructor_unfilled_index = next;
6424
6425   /* ELT now points to the node in the pending tree with the next
6426      initializer to output.  */
6427   goto retry;
6428 }
6429 \f
6430 /* Add one non-braced element to the current constructor level.
6431    This adjusts the current position within the constructor's type.
6432    This may also start or terminate implicit levels
6433    to handle a partly-braced initializer.
6434
6435    Once this has found the correct level for the new element,
6436    it calls output_init_element.  */
6437
6438 void
6439 process_init_element (value)
6440      tree value;
6441 {
6442   tree orig_value = value;
6443   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6444
6445   designator_depth = 0;
6446   designator_errorneous = 0;
6447
6448   /* Handle superfluous braces around string cst as in
6449      char x[] = {"foo"}; */
6450   if (string_flag
6451       && constructor_type
6452       && TREE_CODE (constructor_type) == ARRAY_TYPE
6453       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6454       && integer_zerop (constructor_unfilled_index))
6455     {
6456       if (constructor_stack->replacement_value)
6457         error_init ("excess elements in char array initializer");
6458       constructor_stack->replacement_value = value;
6459       return;
6460     }
6461
6462   if (constructor_stack->replacement_value != 0)
6463     {
6464       error_init ("excess elements in struct initializer");
6465       return;
6466     }
6467
6468   /* Ignore elements of a brace group if it is entirely superfluous
6469      and has already been diagnosed.  */
6470   if (constructor_type == 0)
6471     return;
6472
6473   /* If we've exhausted any levels that didn't have braces,
6474      pop them now.  */
6475   while (constructor_stack->implicit)
6476     {
6477       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6478            || TREE_CODE (constructor_type) == UNION_TYPE)
6479           && constructor_fields == 0)
6480         process_init_element (pop_init_level (1));
6481       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6482                && (constructor_max_index == 0
6483                    || tree_int_cst_lt (constructor_max_index,
6484                                        constructor_index)))
6485         process_init_element (pop_init_level (1));
6486       else
6487         break;
6488     }
6489
6490   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6491   if (constructor_range_stack)
6492     value = save_expr (value);
6493
6494   while (1)
6495     {
6496       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6497         {
6498           tree fieldtype;
6499           enum tree_code fieldcode;
6500
6501           if (constructor_fields == 0)
6502             {
6503               pedwarn_init ("excess elements in struct initializer");
6504               break;
6505             }
6506
6507           fieldtype = TREE_TYPE (constructor_fields);
6508           if (fieldtype != error_mark_node)
6509             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6510           fieldcode = TREE_CODE (fieldtype);
6511
6512           /* Accept a string constant to initialize a subarray.  */
6513           if (value != 0
6514               && fieldcode == ARRAY_TYPE
6515               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6516               && string_flag)
6517             value = orig_value;
6518           /* Otherwise, if we have come to a subaggregate,
6519              and we don't have an element of its type, push into it.  */
6520           else if (value != 0 && !constructor_no_implicit
6521                    && value != error_mark_node
6522                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6523                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6524                        || fieldcode == UNION_TYPE))
6525             {
6526               push_init_level (1);
6527               continue;
6528             }
6529
6530           if (value)
6531             {
6532               push_member_name (constructor_fields);
6533               output_init_element (value, fieldtype, constructor_fields, 1);
6534               RESTORE_SPELLING_DEPTH (constructor_depth);
6535             }
6536           else
6537             /* Do the bookkeeping for an element that was
6538                directly output as a constructor.  */
6539             {
6540               /* For a record, keep track of end position of last field.  */
6541               if (DECL_SIZE (constructor_fields))
6542                 constructor_bit_index
6543                   = size_binop (PLUS_EXPR,
6544                                 bit_position (constructor_fields),
6545                                 DECL_SIZE (constructor_fields));
6546
6547               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6548               /* Skip any nameless bit fields.  */
6549               while (constructor_unfilled_fields != 0
6550                      && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6551                      && DECL_NAME (constructor_unfilled_fields) == 0)
6552                 constructor_unfilled_fields =
6553                   TREE_CHAIN (constructor_unfilled_fields);
6554             }
6555
6556           constructor_fields = TREE_CHAIN (constructor_fields);
6557           /* Skip any nameless bit fields at the beginning.  */
6558           while (constructor_fields != 0
6559                  && DECL_C_BIT_FIELD (constructor_fields)
6560                  && DECL_NAME (constructor_fields) == 0)
6561             constructor_fields = TREE_CHAIN (constructor_fields);
6562         }
6563       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6564         {
6565           tree fieldtype;
6566           enum tree_code fieldcode;
6567
6568           if (constructor_fields == 0)
6569             {
6570               pedwarn_init ("excess elements in union initializer");
6571               break;
6572             }
6573
6574           fieldtype = TREE_TYPE (constructor_fields);
6575           if (fieldtype != error_mark_node)
6576             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6577           fieldcode = TREE_CODE (fieldtype);
6578
6579           /* Warn that traditional C rejects initialization of unions.
6580              We skip the warning if the value is zero.  This is done
6581              under the assumption that the zero initializer in user
6582              code appears conditioned on e.g. __STDC__ to avoid
6583              "missing initializer" warnings and relies on default
6584              initialization to zero in the traditional C case.  */
6585           if (warn_traditional && !in_system_header
6586               && !(value && (integer_zerop (value) || real_zerop (value))))
6587             warning ("traditional C rejects initialization of unions");
6588
6589           /* Accept a string constant to initialize a subarray.  */
6590           if (value != 0
6591               && fieldcode == ARRAY_TYPE
6592               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6593               && string_flag)
6594             value = orig_value;
6595           /* Otherwise, if we have come to a subaggregate,
6596              and we don't have an element of its type, push into it.  */
6597           else if (value != 0 && !constructor_no_implicit
6598                    && value != error_mark_node
6599                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6600                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6601                        || fieldcode == UNION_TYPE))
6602             {
6603               push_init_level (1);
6604               continue;
6605             }
6606
6607           if (value)
6608             {
6609               push_member_name (constructor_fields);
6610               output_init_element (value, fieldtype, constructor_fields, 1);
6611               RESTORE_SPELLING_DEPTH (constructor_depth);
6612             }
6613           else
6614             /* Do the bookkeeping for an element that was
6615                directly output as a constructor.  */
6616             {
6617               constructor_bit_index = DECL_SIZE (constructor_fields);
6618               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6619             }
6620
6621           constructor_fields = 0;
6622         }
6623       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6624         {
6625           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6626           enum tree_code eltcode = TREE_CODE (elttype);
6627
6628           /* Accept a string constant to initialize a subarray.  */
6629           if (value != 0
6630               && eltcode == ARRAY_TYPE
6631               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6632               && string_flag)
6633             value = orig_value;
6634           /* Otherwise, if we have come to a subaggregate,
6635              and we don't have an element of its type, push into it.  */
6636           else if (value != 0 && !constructor_no_implicit
6637                    && value != error_mark_node
6638                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6639                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6640                        || eltcode == UNION_TYPE))
6641             {
6642               push_init_level (1);
6643               continue;
6644             }
6645
6646           if (constructor_max_index != 0
6647               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6648                   || integer_all_onesp (constructor_max_index)))
6649             {
6650               pedwarn_init ("excess elements in array initializer");
6651               break;
6652             }
6653
6654           /* Now output the actual element.  */
6655           if (value)
6656             {
6657               push_array_bounds (tree_low_cst (constructor_index, 0));
6658               output_init_element (value, elttype, constructor_index, 1);
6659               RESTORE_SPELLING_DEPTH (constructor_depth);
6660             }
6661
6662           constructor_index
6663             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6664
6665           if (! value)
6666             /* If we are doing the bookkeeping for an element that was
6667                directly output as a constructor, we must update
6668                constructor_unfilled_index.  */
6669             constructor_unfilled_index = constructor_index;
6670         }
6671
6672       /* Handle the sole element allowed in a braced initializer
6673          for a scalar variable.  */
6674       else if (constructor_fields == 0)
6675         {
6676           pedwarn_init ("excess elements in scalar initializer");
6677           break;
6678         }
6679       else
6680         {
6681           if (value)
6682             output_init_element (value, constructor_type, NULL_TREE, 1);
6683           constructor_fields = 0;
6684         }
6685
6686       /* Handle range initializers either at this level or anywhere higher
6687          in the designator stack.  */
6688       if (constructor_range_stack)
6689         {
6690           struct constructor_range_stack *p, *range_stack;
6691           int finish = 0;
6692
6693           range_stack = constructor_range_stack;
6694           constructor_range_stack = 0;
6695           while (constructor_stack != range_stack->stack)
6696             {
6697               if (!constructor_stack->implicit)
6698                 abort ();
6699               process_init_element (pop_init_level (1));
6700             }
6701           for (p = range_stack;
6702                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6703                p = p->prev)
6704             {
6705               if (!constructor_stack->implicit)
6706                 abort ();
6707               process_init_element (pop_init_level (1));
6708             }
6709
6710           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6711           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6712             finish = 1;
6713
6714           while (1)
6715             {
6716               constructor_index = p->index;
6717               constructor_fields = p->fields;
6718               if (finish && p->range_end && p->index == p->range_start)
6719                 {
6720                   finish = 0;
6721                   p->prev = 0;
6722                 }
6723               p = p->next;
6724               if (!p)
6725                 break;
6726               push_init_level (2);
6727               p->stack = constructor_stack;
6728               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6729                 p->index = p->range_start;
6730             }
6731
6732           if (!finish)
6733             constructor_range_stack = range_stack;
6734           continue;
6735         }
6736
6737       break;
6738     }
6739
6740   constructor_range_stack = 0;
6741 }
6742 \f
6743 /* Build a simple asm-statement, from one string literal.  */
6744 tree
6745 simple_asm_stmt (expr)
6746      tree expr;
6747 {
6748   STRIP_NOPS (expr);
6749
6750   if (TREE_CODE (expr) == ADDR_EXPR)
6751     expr = TREE_OPERAND (expr, 0);
6752
6753   if (TREE_CODE (expr) == STRING_CST)
6754     {
6755       tree stmt;
6756
6757       if (TREE_CHAIN (expr))
6758         expr = combine_strings (expr);
6759       stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr,
6760                                    NULL_TREE, NULL_TREE,
6761                                    NULL_TREE));
6762       ASM_INPUT_P (stmt) = 1;
6763       return stmt;
6764     }
6765
6766   error ("argument of `asm' is not a constant string");
6767   return NULL_TREE;
6768 }
6769
6770 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6771    STRING, some OUTPUTS, some INPUTS, and some CLOBBERS.  */
6772
6773 tree
6774 build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
6775      tree cv_qualifier;
6776      tree string;
6777      tree outputs;
6778      tree inputs;
6779      tree clobbers;
6780 {
6781   tree tail;
6782
6783   if (TREE_CHAIN (string))
6784     string = combine_strings (string);
6785   if (TREE_CODE (string) != STRING_CST)
6786     {
6787       error ("asm template is not a string constant");
6788       return NULL_TREE;
6789     }
6790
6791   if (cv_qualifier != NULL_TREE
6792       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6793     {
6794       warning ("%s qualifier ignored on asm",
6795                IDENTIFIER_POINTER (cv_qualifier));
6796       cv_qualifier = NULL_TREE;
6797     }
6798
6799   /* We can remove output conversions that change the type,
6800      but not the mode.  */
6801   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6802     {
6803       tree output = TREE_VALUE (tail);
6804
6805       STRIP_NOPS (output);
6806       TREE_VALUE (tail) = output;
6807
6808       /* Allow conversions as LHS here.  build_modify_expr as called below
6809          will do the right thing with them.  */
6810       while (TREE_CODE (output) == NOP_EXPR
6811              || TREE_CODE (output) == CONVERT_EXPR
6812              || TREE_CODE (output) == FLOAT_EXPR
6813              || TREE_CODE (output) == FIX_TRUNC_EXPR
6814              || TREE_CODE (output) == FIX_FLOOR_EXPR
6815              || TREE_CODE (output) == FIX_ROUND_EXPR
6816              || TREE_CODE (output) == FIX_CEIL_EXPR)
6817         output = TREE_OPERAND (output, 0);
6818
6819       lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6820     }
6821
6822   /* Remove output conversions that change the type but not the mode.  */
6823   for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6824     {
6825       tree output = TREE_VALUE (tail);
6826       STRIP_NOPS (output);
6827       TREE_VALUE (tail) = output;
6828     }
6829
6830   /* Perform default conversions on array and function inputs.
6831      Don't do this for other types as it would screw up operands
6832      expected to be in memory.  */
6833   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6834     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6835         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6836       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6837
6838   return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6839                                outputs, inputs, clobbers));
6840 }
6841
6842 /* Expand an ASM statement with operands, handling output operands
6843    that are not variables or INDIRECT_REFS by transforming such
6844    cases into cases that expand_asm_operands can handle.
6845
6846    Arguments are same as for expand_asm_operands.  */
6847
6848 void
6849 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6850      tree string, outputs, inputs, clobbers;
6851      int vol;
6852      const char *filename;
6853      int line;
6854 {
6855   int noutputs = list_length (outputs);
6856   int i;
6857   /* o[I] is the place that output number I should be written.  */
6858   tree *o = (tree *) alloca (noutputs * sizeof (tree));
6859   tree tail;
6860
6861   /* Record the contents of OUTPUTS before it is modified.  */
6862   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6863     o[i] = TREE_VALUE (tail);
6864
6865   /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6866      OUTPUTS some trees for where the values were actually stored.  */
6867   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6868
6869   /* Copy all the intermediate outputs into the specified outputs.  */
6870   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6871     {
6872       if (o[i] != TREE_VALUE (tail))
6873         {
6874           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6875                        NULL_RTX, VOIDmode, EXPAND_NORMAL);
6876           free_temp_slots ();
6877
6878           /* Restore the original value so that it's correct the next
6879              time we expand this function.  */
6880           TREE_VALUE (tail) = o[i];
6881         }
6882       /* Detect modification of read-only values.
6883          (Otherwise done by build_modify_expr.)  */
6884       else
6885         {
6886           tree type = TREE_TYPE (o[i]);
6887           if (TREE_READONLY (o[i])
6888               || TYPE_READONLY (type)
6889               || ((TREE_CODE (type) == RECORD_TYPE
6890                    || TREE_CODE (type) == UNION_TYPE)
6891                   && C_TYPE_FIELDS_READONLY (type)))
6892             readonly_warning (o[i], "modification by `asm'");
6893         }
6894     }
6895
6896   /* Those MODIFY_EXPRs could do autoincrements.  */
6897   emit_queue ();
6898 }
6899 \f
6900 /* Expand a C `return' statement.
6901    RETVAL is the expression for what to return,
6902    or a null pointer for `return;' with no value.  */
6903
6904 tree
6905 c_expand_return (retval)
6906      tree retval;
6907 {
6908   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6909
6910   if (TREE_THIS_VOLATILE (current_function_decl))
6911     warning ("function declared `noreturn' has a `return' statement");
6912
6913   if (!retval)
6914     {
6915       current_function_returns_null = 1;
6916       if ((warn_return_type || flag_isoc99)
6917           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6918         pedwarn_c99 ("`return' with no value, in function returning non-void");
6919     }
6920   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6921     {
6922       current_function_returns_null = 1;
6923       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6924         pedwarn ("`return' with a value, in function returning void");
6925     }
6926   else
6927     {
6928       tree t = convert_for_assignment (valtype, retval, _("return"),
6929                                        NULL_TREE, NULL_TREE, 0);
6930       tree res = DECL_RESULT (current_function_decl);
6931       tree inner;
6932
6933       if (t == error_mark_node)
6934         return NULL_TREE;
6935
6936       inner = t = convert (TREE_TYPE (res), t);
6937
6938       /* Strip any conversions, additions, and subtractions, and see if
6939          we are returning the address of a local variable.  Warn if so.  */
6940       while (1)
6941         {
6942           switch (TREE_CODE (inner))
6943             {
6944             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6945             case PLUS_EXPR:
6946               inner = TREE_OPERAND (inner, 0);
6947               continue;
6948
6949             case MINUS_EXPR:
6950               /* If the second operand of the MINUS_EXPR has a pointer
6951                  type (or is converted from it), this may be valid, so
6952                  don't give a warning.  */
6953               {
6954                 tree op1 = TREE_OPERAND (inner, 1);
6955
6956                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6957                        && (TREE_CODE (op1) == NOP_EXPR
6958                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6959                            || TREE_CODE (op1) == CONVERT_EXPR))
6960                   op1 = TREE_OPERAND (op1, 0);
6961
6962                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6963                   break;
6964
6965                 inner = TREE_OPERAND (inner, 0);
6966                 continue;
6967               }
6968
6969             case ADDR_EXPR:
6970               inner = TREE_OPERAND (inner, 0);
6971
6972               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6973                 inner = TREE_OPERAND (inner, 0);
6974
6975               if (TREE_CODE (inner) == VAR_DECL
6976                   && ! DECL_EXTERNAL (inner)
6977                   && ! TREE_STATIC (inner)
6978                   && DECL_CONTEXT (inner) == current_function_decl)
6979                 warning ("function returns address of local variable");
6980               break;
6981
6982             default:
6983               break;
6984             }
6985
6986           break;
6987         }
6988
6989       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6990       current_function_returns_value = 1;
6991     }
6992
6993  return add_stmt (build_return_stmt (retval));
6994 }
6995 \f
6996 struct c_switch {
6997   /* The SWITCH_STMT being built.  */
6998   tree switch_stmt;
6999   /* A splay-tree mapping the low element of a case range to the high
7000      element, or NULL_TREE if there is no high element.  Used to
7001      determine whether or not a new case label duplicates an old case
7002      label.  We need a tree, rather than simply a hash table, because
7003      of the GNU case range extension.  */
7004   splay_tree cases;
7005   /* The next node on the stack.  */
7006   struct c_switch *next;
7007 };
7008
7009 /* A stack of the currently active switch statements.  The innermost
7010    switch statement is on the top of the stack.  There is no need to
7011    mark the stack for garbage collection because it is only active
7012    during the processing of the body of a function, and we never
7013    collect at that point.  */
7014
7015 static struct c_switch *switch_stack;
7016
7017 /* Start a C switch statement, testing expression EXP.  Return the new
7018    SWITCH_STMT.  */
7019
7020 tree
7021 c_start_case (exp)
7022      tree exp;
7023 {
7024   enum tree_code code;
7025   tree type;
7026   struct c_switch *cs;
7027
7028   if (exp != error_mark_node)
7029     {
7030       code = TREE_CODE (TREE_TYPE (exp));
7031       type = TREE_TYPE (exp);
7032
7033       if (! INTEGRAL_TYPE_P (type)
7034           && code != ERROR_MARK)
7035         {
7036           error ("switch quantity not an integer");
7037           exp = integer_zero_node;
7038         }
7039       else
7040         {
7041           tree index;
7042           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7043
7044           if (warn_traditional && !in_system_header
7045               && (type == long_integer_type_node
7046                   || type == long_unsigned_type_node))
7047             warning ("`long' switch expression not converted to `int' in ISO C");
7048
7049           exp = default_conversion (exp);
7050           type = TREE_TYPE (exp);
7051           index = get_unwidened (exp, NULL_TREE);
7052           /* We can't strip a conversion from a signed type to an
7053              unsigned, because if we did, int_fits_type_p would do the
7054              wrong thing when checking case values for being in range,
7055              and it's too hard to do the right thing.  */
7056           if (TREE_UNSIGNED (TREE_TYPE (exp))
7057               == TREE_UNSIGNED (TREE_TYPE (index)))
7058             exp = index;
7059         }
7060     }
7061
7062   /* Add this new SWITCH_STMT to the stack.  */
7063   cs = (struct c_switch *) xmalloc (sizeof (*cs));
7064   cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE);
7065   cs->cases = splay_tree_new (case_compare, NULL, NULL);
7066   cs->next = switch_stack;
7067   switch_stack = cs;
7068
7069   return add_stmt (switch_stack->switch_stmt);
7070 }
7071
7072 /* Process a case label.  */
7073
7074 tree
7075 do_case (low_value, high_value)
7076      tree low_value;
7077      tree high_value;
7078 {
7079   tree label = NULL_TREE;
7080
7081   if (switch_stack)
7082     {
7083       label = c_add_case_label (switch_stack->cases,
7084                                 SWITCH_COND (switch_stack->switch_stmt),
7085                                 low_value, high_value);
7086       if (label == error_mark_node)
7087         label = NULL_TREE;
7088     }
7089   else if (low_value)
7090     error ("case label not within a switch statement");
7091   else
7092     error ("`default' label not within a switch statement");
7093
7094   return label;
7095 }
7096
7097 /* Finish the switch statement.  */
7098
7099 void
7100 c_finish_case ()
7101 {
7102   struct c_switch *cs = switch_stack;
7103
7104   RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt));
7105
7106   /* Pop the stack.  */
7107   switch_stack = switch_stack->next;
7108   splay_tree_delete (cs->cases);
7109   free (cs);
7110 }