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